Add an ExtensionPrefStore, layered between the user prefs nad the managed pre...

chrome/browser/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/pref_service.h"
 
 #include <algorithm>
 #include <string>
 
 #include "app/l10n_util.h"
@@ skipping 12 matching lines @@
 #if defined(OS_WIN)
 #include "chrome/browser/configuration_policy_provider_win.h"
 #elif defined(OS_MACOSX)
 #include "chrome/browser/configuration_policy_provider_mac.h"
 #elif defined(OS_POSIX)
 #include "chrome/browser/config_dir_policy_provider.h"
 #endif
 #include "chrome/browser/dummy_configuration_policy_provider.h"
 
 #include "chrome/browser/configuration_policy_pref_store.h"
+#include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/common/chrome_paths.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
@@ skipping 39 matching lines @@
 // Forwards a notification after a PostMessage so that we can wait for the
 // MessageLoop to run.
 void NotifyReadError(PrefService* pref, int message_id) {
   Source<PrefService> source(pref);
   NotificationService::current()->Notify(NotificationType::PROFILE_ERROR,
                                          source, Details<int>(&message_id));
 }
 
 }  // namespace
 
+// static
 PrefService* PrefService::CreatePrefService(const FilePath& pref_filename) {
   PrefStore* managed_prefs = NULL;
+  ExtensionPrefStore* extension_prefs = new ExtensionPrefStore(NULL);
   PrefStore* local_prefs = new JsonPrefStore(
       pref_filename,
       ChromeThread::GetMessageLoopProxyForThread(ChromeThread::FILE));
   PrefStore* recommended_prefs = NULL;
 
   ConfigurationPolicyProvider* managed_prefs_provider = NULL;
   ConfigurationPolicyProvider* recommended_prefs_provider = NULL;
 
 #if defined(OS_WIN)
   managed_prefs_provider = new ConfigurationPolicyProviderWin();
@@ skipping 16 matching lines @@
 
   // The ConfigurationPolicyPrefStore takes ownership of the passed
   // |provider|.
   managed_prefs = new ConfigurationPolicyPrefStore(
       CommandLine::ForCurrentProcess(),
       managed_prefs_provider);
   recommended_prefs = new ConfigurationPolicyPrefStore(
       CommandLine::ForCurrentProcess(),
       recommended_prefs_provider);
 
-  // The PrefValueStore takes to ownership of the parameters.
+  // The PrefValueStore takes ownership of the PrefStores.
   PrefValueStore* value_store = new PrefValueStore(
       managed_prefs,
+      extension_prefs,
       local_prefs,
       recommended_prefs);
+
+  PrefService* pref_service = new PrefService(value_store);
+  extension_prefs->SetPrefService(pref_service);
+
+  return pref_service;
+}
+
+// static
+PrefService* PrefService::CreateUserPrefService(
+    const FilePath& pref_filename) {
+  PrefValueStore* value_store = new PrefValueStore(
+      NULL, /* no enforced prefs */
+      NULL, /* no extension prefs */
+      new JsonPrefStore(
+          pref_filename,
+          ChromeThread::GetMessageLoopProxyForThread(ChromeThread::FILE)),
+          /* user prefs */
+      NULL /* no advised prefs */);
   return new PrefService(value_store);
 }
 
 PrefService::PrefService(PrefValueStore* pref_value_store)
     : pref_value_store_(pref_value_store) {
   InitFromStorage();
 }
 
 PrefService::~PrefService() {
   DCHECK(CalledOnValidThread());
@@ skipping 224 matching lines @@
 }
 
 const PrefService::Preference* PrefService::FindPreference(
     const wchar_t* pref_name) const {
   DCHECK(CalledOnValidThread());
   Preference p(NULL, pref_name, NULL);
   PreferenceSet::const_iterator it = prefs_.find(&p);
   return it == prefs_.end() ? NULL : *it;
 }
 
+void PrefService::FireObserversIfChanged(const wchar_t* path,
+                                         const Value* old_value) {
+  if (PrefIsChanged(path, old_value))
+    FireObservers(path);
+}
+
+bool PrefService::PrefIsChanged(const wchar_t* path,
+                                const Value* old_value) {
+  Value* new_value = NULL;
+  pref_value_store_->GetValue(path, &new_value);
+  // Some unit tests have no values for certain prefs.
+  return (!new_value || !old_value->Equals(new_value));
+}
+
 const DictionaryValue* PrefService::GetDictionary(const wchar_t* path) const {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to read an unregistered pref: " << path;
     return NULL;
   }
   const Value* value = pref->GetValue();
   if (value->GetType() == Value::TYPE_NULL)
@@ skipping 342 matching lines @@
 }
 
 Value* PrefService::GetPrefCopy(const wchar_t* path) {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   DCHECK(pref);
   return pref->GetValue()->DeepCopy();
 }
 
-void PrefService::FireObserversIfChanged(const wchar_t* path,
-                                         const Value* old_value) {
-  Value* new_value = NULL;
-  pref_value_store_->GetValue(path, &new_value);
-  if (!old_value->Equals(new_value))
-    FireObservers(path);
-}
-
 void PrefService::FireObservers(const wchar_t* path) {
   DCHECK(CalledOnValidThread());
 
   // Convert path to a std::wstring because the Details constructor requires a
   // class.
   std::wstring path_str(path);
   PrefObserverMap::iterator observer_iterator = pref_observers_.find(path_str);
   if (observer_iterator == pref_observers_.end())
     return;
 
@@ skipping 46 matching lines @@
 
 bool PrefService::Preference::IsDefaultValue() const {
   DCHECK(default_value_.get());
   return default_value_->Equals(GetValue());
 }
 
 bool PrefService::Preference::IsManaged() const {
   return pref_value_store_->PrefValueIsManaged(name_.c_str());
 }