Clean up pref change notification handling.

chrome/browser/prefs/pref_service.cc

 // Copyright (c) 2010 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_service.h"
 
 #include <algorithm>
 #include <string>
 
 #include "app/l10n_util.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_thread.h"
-#include "chrome/browser/prefs/pref_notifier.h"
+#include "chrome/browser/policy/configuration_policy_pref_store.h"
+#include "chrome/browser/prefs/command_line_pref_store.h"
+#include "chrome/browser/prefs/in_memory_pref_store.h"
+#include "chrome/browser/prefs/pref_notifier_impl.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/json_pref_store.h"
 #include "chrome/common/notification_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 
 namespace {
 
 // A helper function for RegisterLocalized*Pref that creates a Value* based on
 // the string value in the locale dll.  Because we control the values in a
 // locale dll, this should always return a Value of the appropriate type.
 Value* CreateLocaleDefaultValue(Value::ValueType type, int message_id) {
@@ skipping 39 matching lines @@
   Source<PrefService> source(pref);
   NotificationService::current()->Notify(NotificationType::PROFILE_ERROR,
                                          source, Details<int>(&message_id));
 }
 
 }  // namespace
 
 // static
 PrefService* PrefService::CreatePrefService(const FilePath& pref_filename,
                                             Profile* profile) {
+  using policy::ConfigurationPolicyPrefStore;
+
 #if defined(OS_LINUX)
   // We'd like to see what fraction of our users have the preferences
   // stored on a network file system, as we've had no end of troubles
   // with NFS/AFS.
   // TODO(evanm): remove this once we've collected state.
   file_util::FileSystemType fstype;
   if (file_util::GetFileSystemType(pref_filename.DirName(), &fstype)) {
     UMA_HISTOGRAM_ENUMERATION("PrefService.FileSystemType",
                               static_cast<int>(fstype),
                               file_util::FILE_SYSTEM_TYPE_COUNT);
   }
 #endif
 
-  return new PrefService(
-      PrefValueStore::CreatePrefValueStore(pref_filename, profile, false));
+  ConfigurationPolicyPrefStore* managed =
+      ConfigurationPolicyPrefStore::CreateManagedPlatformPolicyPrefStore();
+  ConfigurationPolicyPrefStore* device_management =
+      ConfigurationPolicyPrefStore::CreateDeviceManagementPolicyPrefStore(
+          profile);
+  InMemoryPrefStore* extension = new InMemoryPrefStore();
+  CommandLinePrefStore* command_line =
+      new CommandLinePrefStore(CommandLine::ForCurrentProcess());
+  JsonPrefStore* user = new JsonPrefStore(
+      pref_filename,
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
+  ConfigurationPolicyPrefStore* recommended =
+      ConfigurationPolicyPrefStore::CreateRecommendedPolicyPrefStore();
+
+  return new PrefService(managed, device_management, extension, command_line,
+                         user, recommended, profile);
 }
 
 // static
 PrefService* PrefService::CreateUserPrefService(const FilePath& pref_filename) {
-  return new PrefService(
-      PrefValueStore::CreatePrefValueStore(pref_filename, NULL, true));
+  JsonPrefStore* user = new JsonPrefStore(
+      pref_filename,
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
+  InMemoryPrefStore* extension = new InMemoryPrefStore();
+
+  return new PrefService(NULL, NULL, extension, NULL, user, NULL, NULL);
 }
 
-PrefService::PrefService(PrefValueStore* pref_value_store)
-    : pref_value_store_(pref_value_store) {
-  pref_notifier_.reset(new PrefNotifier(this, pref_value_store));
+PrefService::PrefService(PrefStore* managed_platform_prefs,
+                         PrefStore* device_management_prefs,
+                         PrefStore* extension_prefs,
+                         PrefStore* command_line_prefs,
+                         PrefStore* user_prefs,
+                         PrefStore* recommended_prefs,
+                         Profile* profile) {
+  pref_notifier_.reset(new PrefNotifierImpl(this));
+  extension_store_ = extension_prefs;
+  default_store_ = new InMemoryPrefStore();
+  pref_value_store_ =
+      new PrefValueStore(managed_platform_prefs,
+                         device_management_prefs,
+                         extension_store_,
+                         command_line_prefs,
+                         user_prefs,
+                         recommended_prefs,
+                         default_store_,
+                         pref_notifier_.get(),
+                         profile);
   InitFromStorage();
 }
 
 PrefService::~PrefService() {
   DCHECK(CalledOnValidThread());
   STLDeleteContainerPointers(prefs_.begin(), prefs_.end());
   prefs_.clear();
 }
 
 void PrefService::InitFromStorage() {
@@ skipping 190 matching lines @@
 }
 
 const PrefService::Preference* PrefService::FindPreference(
     const char* pref_name) const {
   DCHECK(CalledOnValidThread());
   Preference p(this, pref_name);
   PreferenceSet::const_iterator it = prefs_.find(&p);
   return it == prefs_.end() ? NULL : *it;
 }
 
+bool PrefService::ReadOnly() const {
+  return pref_value_store_->ReadOnly();
+}
+
+PrefNotifier* PrefService::pref_notifier() const {
+  return pref_notifier_.get();
+}
+
+PrefStore* PrefService::GetExtensionPrefStore() {
+  return extension_store_;
+}
+
 bool PrefService::IsManagedPreference(const char* pref_name) const {
   const Preference* pref = FindPreference(pref_name);
   if (pref && pref->IsManaged()) {
     return true;
   }
   return false;
 }
 
 const DictionaryValue* PrefService::GetDictionary(const char* path) const {
   DCHECK(CalledOnValidThread());
@@ skipping 16 matching lines @@
   if (!pref) {
     NOTREACHED() << "Trying to read an unregistered pref: " << path;
     return NULL;
   }
   const Value* value = pref->GetValue();
   if (value->GetType() == Value::TYPE_NULL)
     return NULL;
   return static_cast<const ListValue*>(value);
 }
 
-bool PrefService::ReadOnly() const {
-  return pref_value_store_->ReadOnly();
-}
-
 void PrefService::AddPrefObserver(const char* path,
                                   NotificationObserver* obs) {
   pref_notifier_->AddPrefObserver(path, obs);
 }
 
 void PrefService::RemovePrefObserver(const char* path,
                                      NotificationObserver* obs) {
   pref_notifier_->RemovePrefObserver(path, obs);
 }
 
 void PrefService::RegisterPreference(const char* path, Value* default_value) {
   DCHECK(CalledOnValidThread());
 
   // The main code path takes ownership, but most don't. We'll be safe.
   scoped_ptr<Value> scoped_value(default_value);
 
   if (FindPreference(path)) {
     NOTREACHED() << "Tried to register duplicate pref " << path;
     return;
   }
 
   Value::ValueType orig_type = default_value->GetType();
   DCHECK(orig_type != Value::TYPE_NULL && orig_type != Value::TYPE_BINARY) <<
          "invalid preference type: " << orig_type;
 
   // We set the default value of dictionaries and lists to be null so it's
   // easier for callers to check for empty dict/list prefs. The PrefValueStore
   // accepts ownership of the value (null or default_value).
   if (Value::TYPE_LIST == orig_type || Value::TYPE_DICTIONARY == orig_type) {
-    pref_value_store_->SetDefaultPrefValue(path, Value::CreateNullValue());
+    default_store_->prefs()->Set(path, Value::CreateNullValue());
   } else {
     // Hand off ownership.
     DCHECK(!PrefStore::IsUseDefaultSentinelValue(default_value));
-    pref_value_store_->SetDefaultPrefValue(path, scoped_value.release());
+    default_store_->prefs()->Set(path, scoped_value.release());
   }
 
   pref_value_store_->RegisterPreferenceType(path, orig_type);
   prefs_.insert(new Preference(this, path));
 }
 
 void PrefService::ClearPref(const char* path) {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to clear an unregistered pref: " << path;
     return;
   }
-  if (pref_value_store_->RemoveUserPrefValue(path))
-    pref_notifier_->OnUserPreferenceSet(path);
+  pref_value_store_->RemoveUserPrefValue(path);
 }
 
 void PrefService::Set(const char* path, const Value& value) {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to write an unregistered pref: " << path;
     return;
   }
 
   // Allow dictionary and list types to be set to null, which removes their
   // user values.
-  bool value_changed = false;
   if (value.GetType() == Value::TYPE_NULL &&
       (pref->GetType() == Value::TYPE_DICTIONARY ||
        pref->GetType() == Value::TYPE_LIST)) {
-    value_changed = pref_value_store_->RemoveUserPrefValue(path);
+    pref_value_store_->RemoveUserPrefValue(path);
   } else if (pref->GetType() != value.GetType()) {
     NOTREACHED() << "Trying to set pref " << path
                  << " of type " << pref->GetType()
                  << " to value of type " << value.GetType();
   } else {
-    value_changed = pref_value_store_->SetUserPrefValue(path, value.DeepCopy());
+    pref_value_store_->SetUserPrefValue(path, value.DeepCopy());
   }
-
-  if (value_changed)
-    pref_notifier_->OnUserPreferenceSet(path);
 }
 
 void PrefService::SetBoolean(const char* path, bool value) {
   SetUserPrefValue(path, Value::CreateBooleanValue(value));
 }
 
 void PrefService::SetInteger(const char* path, int value) {
   SetUserPrefValue(path, Value::CreateIntegerValue(value));
 }
 
@@ skipping 57 matching lines @@
     return NULL;
   }
 
   DictionaryValue* dict = NULL;
   Value* tmp_value = NULL;
   // Look for an existing preference in the user store. If it doesn't
   // exist or isn't the correct type, create a new user preference.
   if (!pref_value_store_->GetUserValue(path, &tmp_value) ||
       !tmp_value->IsType(Value::TYPE_DICTIONARY)) {
     dict = new DictionaryValue;
-    pref_value_store_->SetUserPrefValue(path, dict);
+    pref_value_store_->SetUserPrefValueSilently(path, dict);
   } else {
     dict = static_cast<DictionaryValue*>(tmp_value);
   }
   return dict;
 }
 
 ListValue* PrefService::GetMutableList(const char* path) {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to get an unregistered pref: " << path;
     return NULL;
   }
   if (pref->GetType() != Value::TYPE_LIST) {
     NOTREACHED() << "Wrong type for GetMutableList: " << path;
     return NULL;
   }
 
   ListValue* list = NULL;
   Value* tmp_value = NULL;
   // Look for an existing preference in the user store. If it doesn't
   // exist or isn't the correct type, create a new user preference.
   if (!pref_value_store_->GetUserValue(path, &tmp_value) ||
       !tmp_value->IsType(Value::TYPE_LIST)) {
     list = new ListValue;
-    pref_value_store_->SetUserPrefValue(path, list);
+    pref_value_store_->SetUserPrefValueSilently(path, list);
   } else {
     list = static_cast<ListValue*>(tmp_value);
   }
   return list;
 }
 
 Value* PrefService::GetPrefCopy(const char* path) {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
@@ skipping 13 matching lines @@
     NOTREACHED() << "Preference is managed: " << path;
     return;
   }
   if (pref->GetType() != new_value->GetType()) {
     NOTREACHED() << "Trying to set pref " << path
                  << " of type " << pref->GetType()
                  << " to value of type " << new_value->GetType();
     return;
   }
 
-  if (pref_value_store_->SetUserPrefValue(path, new_value))
-    pref_notifier_->OnUserPreferenceSet(path);
-}
-
-PrefStore* PrefService::GetExtensionPrefStore() const {
-  return pref_value_store()->GetExtensionPrefStore();
+  pref_value_store_->SetUserPrefValue(path, new_value);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // PrefService::Preference
 
 PrefService::Preference::Preference(const PrefService* service,
                                     const char* name)
       : name_(name),
         pref_service_(service) {
   DCHECK(name);
@@ skipping 46 matching lines @@
 
 bool PrefService::Preference::IsDefaultValue() const {
   return pref_service_->pref_value_store_->
       PrefValueFromDefaultStore(name_.c_str());
 }
 
 bool PrefService::Preference::IsUserModifiable() const {
   return pref_service_->pref_value_store_->
       PrefValueUserModifiable(name_.c_str());
 }