Use PrefChangeRegistrar everywhere

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/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 #include "chrome/common/pref_store.h"
 
 class FilePath;
 class NotificationObserver;
+class PrefChangeObserver;
 class PrefNotifier;
 class Profile;
 
+namespace subtle {
+  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,
     // dictionary (a branch), or list.  You shouldn't need to construct this on
     // your own; use the PrefService::Register*Pref methods instead.
@@ skipping 119 matching lines @@
   int GetInteger(const char* path) const;
   double GetReal(const char* path) const;
   std::string GetString(const char* path) const;
   FilePath GetFilePath(const char* path) const;
 
   // Returns the branch if it exists.  If it's not a branch or the branch does
   // not exist, returns NULL.
   const DictionaryValue* GetDictionary(const char* path) const;
   const ListValue* GetList(const char* path) const;
 
-  // If the pref at the given path changes, we call the observer's Observe
-  // method with NOTIFY_PREF_CHANGED.
-  virtual void AddPrefObserver(const char* path, NotificationObserver* obs);
-  virtual void RemovePrefObserver(const char* path, NotificationObserver* obs);
-
   // Removes a user pref and restores the pref to its default value.
   void ClearPref(const char* path);
 
   // If the path is valid (i.e., registered), update the pref value in the user
   // prefs. Seting a null value on a preference of List or Dictionary type is
   // equivalent to removing the user value for that preference, allowing the
   // default value to take effect unless another value takes precedence.
   void Set(const char* path, const Value& value);
   void SetBoolean(const char* path, bool value);
   void SetInteger(const char* path, int value);
@@ skipping 43 matching lines @@
 
   PrefValueStore* pref_value_store() const { return pref_value_store_.get(); }
 
  protected:
   // 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_;
 
  private:
+  // 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
+  // method with NOTIFY_PREF_CHANGED. Note that observers should not call
+  // these methods directly but rather use a PrefChangeRegistrar to make sure
+  // the observer gets cleaned up properly.
+  virtual void AddPrefObserver(const char* path, NotificationObserver* obs);
+  virtual void RemovePrefObserver(const char* path, NotificationObserver* obs);
+
   // Add a preference to the PreferenceMap.  If the pref already exists, return
   // false.  This method takes ownership of |default_value|.
   void RegisterPreference(const char* path, Value* default_value);
 
   // Returns a copy of the current pref value.  The caller is responsible for
   // deleting the returned object.
   Value* GetPrefCopy(const char* pref_name);
 
   // Sets the value for this pref path in the user pref store and informs the
   // PrefNotifier of the change.
@@ skipping 10 matching lines @@
   // and owned by this PrefService. Subclasses may access it for unit testing.
   scoped_refptr<PrefValueStore> pref_value_store_;
 
   // A set of all the registered Preference objects.
   PreferenceSet prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefService);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_SERVICE_H_