Create a DefaultPrefStore to hold registered application-default preference v...

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
 
@@ skipping 10 matching lines @@
 class NotificationObserver;
 class PrefNotifier;
 class Profile;
 
 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 of |default_value|.
-    // Therefore, the type needs to be a boolean, integer, real, string,
+    // 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.
-    // |default_value| will be owned by the Preference object.
-    Preference(PrefValueStore* pref_value_store,
+    // your own; use the PrefService::Register*Pref methods instead.
+    Preference(const PrefService* service,
                const char* name,
-               Value* default_value);
+               Value::ValueType type);
     ~Preference() {}
 
     Value::ValueType type() const { return type_; }
 
     // Returns the name of the Preference (i.e., the key, e.g.,
     // browser.window_placement).
     const std::string name() const { return name_; }
 
-    // Returns the value of the Preference.  If there is no user specified
-    // value, it returns the default value.
+    // Returns the value of the Preference, falling back to the registered
+    // default value if no other has been set.
     const Value* GetValue() const;
 
-    // Returns true if the current value matches the default value.
-    bool IsDefaultValue() const;
-
     // Returns true if the Preference is managed, i.e. set by an admin policy.
     // Since managed prefs have the highest priority, this also indicates
     // whether the pref is actually being controlled by the policy setting.
     bool IsManaged() const;
 
     // Returns true if the Preference has a value set by an extension, even if
     // that value is being overridden by a higher-priority source.
     bool HasExtensionSetting() const;
 
     // Returns true if the Preference has a user setting, even if that value is
     // being overridden by a higher-priority source.
     bool HasUserSetting() const;
 
     // Returns true if the Preference value is currently being controlled by an
     // extension, and not by any higher-priority source.
     bool IsExtensionControlled() const;
 
     // Returns true if the Preference value is currently being controlled by a
     // user setting, and not by any higher-priority source.
     bool IsUserControlled() const;
 
+    // Returns true if the Preference is currently using its default value,
+    // and has not been set by any higher-priority source (even with the same
+    // value).
+    bool IsDefaultValue() const;
+
     // Returns true if the user can change the Preference value, which is the
     // case if no higher-priority source than the user store controls the
     // Preference.
     bool IsUserModifiable() const;
 
    private:
     friend class PrefService;
 
     Value::ValueType type_;
     std::string name_;
-    scoped_ptr<Value> default_value_;
 
-    // A reference to the pref service's pref_value_store_.
-    PrefValueStore* pref_value_store_;
+    // 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.
   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|, and no other PrefStores (i.e., no other types of
-  // preferences).
+  // |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
@@ skipping 49 matching lines @@
 
   // 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.
+  // 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);
   void SetReal(const char* path, double value);
   void SetString(const char* path, const std::string& value);
   void SetFilePath(const char* path, const FilePath& value);
 
   // Int64 helper methods that actually store the given value as a string.
   // Note that if obtaining the named value via GetDictionary or GetList, the
   // Value type will be TYPE_STRING.
@@ skipping 27 matching lines @@
   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 read_only() const { return pref_value_store_->ReadOnly(); }
 
   PrefNotifier* pref_notifier() const { return pref_notifier_.get(); }
 
+  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:
   // Add a preference to the PreferenceMap.  If the pref already exists, return
-  // false.  This method takes ownership of |pref|.
-  void RegisterPreference(Preference* pref);
+  // 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.
+  void SetUserPrefValue(const char* path, Value* new_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 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_;
 
   // A set of all the registered Preference objects.
   PreferenceSet prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefService);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_SERVICE_H_