Provide access to recommended pref values

chrome/browser/prefs/pref_value_store.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/prefs/pref_value_store.h"
 
 #include "base/logging.h"
 #include "chrome/browser/prefs/pref_model_associator.h"
 #include "chrome/browser/prefs/pref_notifier.h"
 
@@ skipping 82 matching lines @@
     default_prefs = GetPrefStore(DEFAULT_STORE);
 
   return new PrefValueStore(
       managed_prefs, extension_prefs, command_line_prefs, user_prefs,
       recommended_prefs, default_prefs, pref_sync_associator, pref_notifier);
 }
 
 bool PrefValueStore::GetValue(const std::string& name,
                               base::Value::Type type,
                               const Value** out_value) const {
-  *out_value = NULL;
-  // Check the |PrefStore|s in order of their priority from highest to lowest
-  // to find the value of the preference described by the given preference name.
+  // Check the |PrefStore|s in order of their priority from highest to lowest,
+  // looking for the first preference value with the given |name| and |type|.
   for (size_t i = 0; i <= PREF_STORE_TYPE_MAX; ++i) {
-    if (GetValueFromStore(name.c_str(), static_cast<PrefStoreType>(i),
-                          out_value)) {
-      if (!(*out_value)->IsType(type)) {
-        LOG(WARNING) << "Expected type for " << name << " is " << type
-                     << " but got " << (*out_value)->GetType()
-                     << " in store " << i;
-        continue;
-      }
+    if (GetValueFromStoreWithType(name.c_str(), type,
+                                  static_cast<PrefStoreType>(i), out_value))
       return true;
-    }
   }
   return false;
 }
 
+bool PrefValueStore::GetRecommendedValue(const std::string& name,
+                                         base::Value::Type type,
+                                         const Value** out_value) const {
+  return GetValueFromStoreWithType(name.c_str(), type, RECOMMENDED_STORE,
+                                   out_value);
+}
+
 void PrefValueStore::NotifyPrefChanged(
     const char* path,
     PrefValueStore::PrefStoreType new_store) {
   DCHECK(new_store != INVALID_STORE);
-
-  // If the pref is controlled by a higher-priority store, its effective value
-  // cannot have changed.
-  PrefStoreType controller = ControllingPrefStoreForPref(path);
-  if (controller == INVALID_STORE || controller >= new_store) {
-    pref_notifier_->OnPreferenceChanged(path);
-    if (pref_sync_associator_)
-      pref_sync_associator_->ProcessPrefChange(path);
-  }
+  // A notification is sent when the pref value in any store changes. If this
+  // store is currently being overridden by a higher-priority store, the
+  // effective value of the pref will not have changed.
+  pref_notifier_->OnPreferenceChanged(path);
+  if (pref_sync_associator_)
+    pref_sync_associator_->ProcessPrefChange(path);
 }
 
 bool PrefValueStore::PrefValueInManagedStore(const char* name) const {
   return PrefValueInStore(name, MANAGED_STORE);
 }
 
 bool PrefValueStore::PrefValueInExtensionStore(const char* name) const {
   return PrefValueInStore(name, EXTENSION_STORE);
 }
 
@@ skipping 88 matching lines @@
       case PrefStore::READ_NO_VALUE:
         break;
     }
   }
 
   // No valid value found for the given preference name: set the return false.
   *out_value = NULL;
   return false;
 }
 
+bool PrefValueStore::GetValueFromStoreWithType(const char* name,
+                                               base::Value::Type type,
+                                               PrefStoreType store,
+                                               const Value** out_value) const {
+  if (GetValueFromStore(name, store, out_value)) {
+    if ((*out_value)->IsType(type))
+      return true;
+
+    LOG(WARNING) << "Expected type for " << name << " is " << type
+                 << " but got " << (*out_value)->GetType()
+                 << " in store " << store;
+  }
+
+  *out_value = NULL;
+  return false;
+}
+
 void PrefValueStore::OnPrefValueChanged(PrefValueStore::PrefStoreType type,
                                         const std::string& key) {
   NotifyPrefChanged(key.c_str(), type);
 }
 
 void PrefValueStore::OnInitializationCompleted(
     PrefValueStore::PrefStoreType type, bool succeeded) {
   if (initialization_failed_)
     return;
   if (!succeeded) {
@@ skipping 13 matching lines @@
   if (initialization_failed_)
     return;
   for (size_t i = 0; i <= PREF_STORE_TYPE_MAX; ++i) {
     scoped_refptr<PrefStore> store =
         GetPrefStore(static_cast<PrefStoreType>(i));
     if (store && !store->IsInitializationComplete())
       return;
   }
   pref_notifier_->OnInitializationCompleted(true);
 }