Clean up pref change notification handling.

chrome/browser/prefs/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_PREFS_PREF_SERVICE_H_
 #define CHROME_BROWSER_PREFS_PREF_SERVICE_H_
 #pragma once
 
 #include <set>
 #include <string>
 
 #include "base/non_thread_safe.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/common/pref_store.h"
 
+class DefaultPrefStore;
 class FilePath;
 class NotificationObserver;
 class PrefChangeObserver;
 class PrefNotifier;
+class PrefNotifierImpl;
 class PrefValueStore;
 class Profile;
 
 namespace subtle {
-  class PrefMemberBase;
+class PrefMemberBase;
 };
 
 class PrefService : public NonThreadSafe {
  public:
   // A helper class to store all the information associated with a preference.
   class Preference {
    public:
 
     // The type of the preference is determined by the type with which it is
     // registered. This type needs to be a boolean, integer, real, string,
@@ skipping 49 matching lines @@
     friend class PrefService;
 
     std::string name_;
 
     // Reference to the PrefService in which this pref was created.
     const PrefService* pref_service_;
 
     DISALLOW_COPY_AND_ASSIGN(Preference);
   };
 
-  // Factory method that creates a new instance of a PrefService with
-  // a PrefValueStore containing all platform-applicable PrefStores.
-  // The |pref_filename| points to the user preference file. The |profile| is
-  // the one to which these preferences apply; it may be NULL if we're dealing
-  // with the local state. This is the usual way to create a new PrefService.
+  // Factory method that creates a new instance of a PrefService with the
+  // applicable PrefStores. The |pref_filename| points to the user preference
+  // file. The |profile| is the one to which these preferences apply; it may be
+  // NULL if we're dealing with the local state. This is the usual way to create
+  // a new PrefService.
   static PrefService* CreatePrefService(const FilePath& pref_filename,
                                         Profile* profile);
 
   // Convenience factory method for use in unit tests. Creates a new
   // PrefService that uses a PrefValueStore with user preferences at the given
   // |pref_filename|, a default PrefStore, 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 |pref_value_store|
-  // provides preference values.
-  explicit PrefService(PrefValueStore* pref_value_store);
-
   virtual ~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();
 
   // Returns true if the preference for the given preference name is available
   // and is managed.
   bool IsManagedPreference(const char* pref_name) const;
@@ skipping 88 matching lines @@
   };
   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 char* pref_name) const;
 
   bool ReadOnly() const;
 
-  PrefNotifier* pref_notifier() const { return pref_notifier_.get(); }
+  // TODO(mnissler): This should not be public. Change client code to call a
+  // preference setter or use ScopedPrefUpdate.
+  PrefNotifier* pref_notifier() const;
 
-  PrefValueStore* pref_value_store() const { return pref_value_store_.get(); }
-
-  PrefStore* GetExtensionPrefStore() const;
+  // Get the extension PrefStore.
+  PrefStore* GetExtensionPrefStore();
 
  protected:
+  // Construct a new pref service, specifying the pref sources as explicit
+  // PrefStore pointers. This constructor is what CreatePrefService() ends up
+  // calling. It's also used for unit tests.
+  PrefService(PrefStore* managed_platform_prefs,
+              PrefStore* device_management_prefs,
+              PrefStore* extension_prefs,
+              PrefStore* command_line_prefs,
+              PrefStore* user_prefs,
+              PrefStore* recommended_prefs,
+              Profile* profile);
+
   // The PrefNotifier handles registering and notifying preference observers.
   // It is created and owned by this PrefService. Subclasses may access it for
   // unit testing.
-  scoped_ptr<PrefNotifier> pref_notifier_;
+  scoped_ptr<PrefNotifierImpl> pref_notifier_;
 
  private:
+  friend class TestingPrefService;
+
   // Registration of pref change observers must be done using the
   // PrefChangeRegistrar, which is declared as a friend here to grant it
   // access to the otherwise protected members Add/RemovePrefObserver.
   // PrefMember registers for preferences changes notification directly to
   // avoid the storage overhead of the registrar, so its base class must be
   // declared as a friend, too.
   friend class PrefChangeRegistrar;
   friend class subtle::PrefMemberBase;
 
   // If the pref at the given path changes, we call the observer's Observe
@@ skipping 19 matching lines @@
   PrefStore::PrefReadError LoadPersistentPrefs();
 
   // Load preferences from storage, attempting to diagnose and handle errors.
   // This should only be called from the constructor.
   void InitFromStorage();
 
   // The PrefValueStore provides prioritized preference values. It is created
   // and owned by this PrefService. Subclasses may access it for unit testing.
   scoped_refptr<PrefValueStore> pref_value_store_;
 
+  // The extension pref store registered with the PrefValueStore.
+  PrefStore* extension_store_;
+
+  // Points to the default pref store we passed to the PrefValueStore.
+  PrefStore* default_store_;
+
   // A set of all the registered Preference objects.
   PreferenceSet prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefService);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_SERVICE_H_