Introduce incognito preference settings.

chrome/browser/prefs/pref_service.h

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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>
@@ skipping 23 matching lines @@
  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.
     Preference(const PrefService* service,
-               const char* name);
+               const char* name,
+               Value::ValueType type);
     ~Preference() {}
 
     // Returns the name of the Preference (i.e., the key, e.g.,
     // browser.window_placement).
     const std::string name() const { return name_; }
 
     // Returns the registered type of the preference.
     Value::ValueType GetType() const;
 
     // Returns the value of the Preference, falling back to the registered
@@ skipping 29 matching lines @@
     // 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;
 
     std::string name_;
 
+    Value::ValueType type_;
+
     // 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 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. |extension_pref_store| is used as the source for
   // extension-controlled preferences and may be NULL. The PrefService takes
   // ownership of |extension_pref_store|.
   static PrefService* CreatePrefService(const FilePath& pref_filename,
                                         PrefStore* extension_pref_store,
                                         Profile* profile);
 
+  // Creates an incognito copy of the pref service that shares most pref stores
+  // but uses a fresh non-persistent overlay for the user pref store and an
+  // individual extension pref store (to cache the effective extension prefs for
+  // incognito windows).
+  PrefService* CreateIncognitoPrefService(PrefStore* incognito_extension_prefs);
+
   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 101 matching lines @@
 
  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,
               PersistentPrefStore* user_prefs,
-              PrefStore* recommended_prefs);
+              PrefStore* recommended_prefs,
+              DefaultPrefStore* default_store);
 
   // 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<PrefNotifierImpl> pref_notifier_;
 
  private:
   friend class PrefServiceMockBuilder;
 
   // 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;
 
+  // Construct an incognito version of the pref service. Use
+  // CreateIncognitoPrefService() instead of calling this constructor directly.
+  PrefService(const PrefService& original,
+              PrefStore* incognito_extension_prefs);
+
   // If the pref at the given path changes, we call the observer's Observe
   // method with 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);
 
   // 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 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 persistent pref store used for actual user data.
-  PersistentPrefStore* user_pref_store_;
+  // Pref Stores and profile that we passed to the PrefValueStore.
+  scoped_refptr<PersistentPrefStore> user_pref_store_;
+  scoped_refptr<DefaultPrefStore> default_store_;
 
-  // Points to the default pref store we passed to the PrefValueStore.
-  DefaultPrefStore* default_store_;
-
-  // A set of all the registered Preference objects.
-  PreferenceSet prefs_;
+  // Local cache of registered Preference objects. The default_store_
+  // is authoritative with respect to what the types and default values
+  // of registered preferences are.
+  mutable PreferenceSet prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefService);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_SERVICE_H_