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

chrome/browser/pref_service.h

 // 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.
 
 // This provides a way to access the application's current preferences.
 
 #ifndef CHROME_BROWSER_PREF_SERVICE_H_
 #define CHROME_BROWSER_PREF_SERVICE_H_
 
 #include <set>
@@ skipping 51 matching lines @@
     Value::ValueType type_;
     std::wstring name_;
     scoped_ptr<Value> default_value_;
 
     // A reference to the pref service's pref_value_store_.
     PrefValueStore* pref_value_store_;
 
     DISALLOW_COPY_AND_ASSIGN(Preference);
   };
 
-  // Factory method that creates a new instance of a |PrefService|.
+  // Factory method that creates a new instance of a |PrefService| with
+  // all platform-applicable PrefStores (managed, extension, user, etc.).
+  // This is the usual way to create a new PrefService.
   static PrefService* CreatePrefService(const FilePath& pref_filename);
 
-  // The |PrefValueStore| provides preference values.
+  // Convenience factory method for use in unit tests. Creates a new
+  // PrefService that uses a PrefValueStore with user preferences at the given
+  // |pref_filename|, and no other PrefStores (i.e., no other types of
+  // preferences).
+  static PrefService* CreateUserPrefService(const FilePath& pref_filename);
+
+  // This constructor is primarily used by tests. The |PrefValueStore| provides
+  // preference values.
   explicit PrefService(PrefValueStore* pref_value_store);
+
   ~PrefService();
 
   // Reloads the data from file. This should only be called when the importer
   // is running during first run, and the main process may not change pref
   // values while the importer process is running. Returns true on success.
   bool ReloadPersistentPrefs();
 
   // Writes the data to disk. The return value only reflects whether
   // serialization was successful; we don't know whether the data actually made
   // it on disk (since it's on a different thread).  This should only be used if
@@ skipping 87 matching lines @@
       return lhs->name() < rhs->name();
     }
   };
   typedef std::set<Preference*, PreferencePathComparator> PreferenceSet;
   const PreferenceSet& preference_set() const { return prefs_; }
 
   // A helper method to quickly look up a preference.  Returns NULL if the
   // preference is not registered.
   const Preference* FindPreference(const wchar_t* pref_name) const;
 
+  // For the given pref_name, fire any observer of the pref only if |old_value|
+  // is different from the current value.  Virtual so it can be mocked for a
+  // unit test.
+  virtual void FireObserversIfChanged(const wchar_t* pref_name,
+                                      const Value* old_value);
+
   bool read_only() const { return pref_value_store_->ReadOnly(); }
 
+ protected:
+  // This should only be accessed by subclasses for unit-testing.
+  bool PrefIsChanged(const wchar_t* path, const Value* old_value);
+
  private:
   // Add a preference to the PreferenceMap.  If the pref already exists, return
   // false.  This method takes ownership of |pref|.
   void RegisterPreference(Preference* pref);
 
   // Returns a copy of the current pref value.  The caller is responsible for
   // deleting the returned object.
   Value* GetPrefCopy(const wchar_t* pref_name);
 
   // For the given pref_name, fire any observer of the pref.
   void FireObservers(const wchar_t* pref_name);
 
-  // For the given pref_name, fire any observer of the pref only if |old_value|
-  // is different from the current value.
-  void FireObserversIfChanged(const wchar_t* pref_name,
-                              const Value* old_value);
-
   // Load from disk.  Returns a non-zero error code on failure.
   PrefStore::PrefReadError LoadPersistentPrefs();
 
   // Load preferences from storage, attempting to diagnose and handle errors.
   // This should only be called from the constructor.
   void InitFromStorage();
 
   // The value of a Preference can be:
   // managed, user defined, recommended or default.
   // The PrefValueStore manages enforced, user defined and recommended values
@@ skipping 11 matching lines @@
   typedef base::hash_map<std::wstring, NotificationObserverList*>
       PrefObserverMap;
   PrefObserverMap pref_observers_;
 
   friend class ScopedPrefUpdate;
 
   DISALLOW_COPY_AND_ASSIGN(PrefService);
 };
 
 #endif  // CHROME_BROWSER_PREF_SERVICE_H_