Introduce incognito preference settings.

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 24 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);
+  static PrefService* CreatePrefService(
+      const FilePath& pref_filename,
+      scoped_refptr<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(
+      scoped_refptr<PrefStore> incognito_extension_prefs);

[Mattias Nissler (ping if slow), 2010/12/20 14:50:02]

We should have a unit test for this, ensuring that values stored in the
incognito service don't end up in the original PrefService.

[battre, 2010/12/21 18:51:59]

Done.

 
   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.
@@ skipping 97 matching lines @@
   bool ReadOnly() const;
 
   // TODO(mnissler): This should not be public. Change client code to call a
   // preference setter or use ScopedPrefUpdate.
   PrefNotifier* pref_notifier() const;
 
  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,
+  PrefService(scoped_refptr<PrefStore> managed_platform_prefs,

[Mattias Nissler (ping if slow), 2010/12/20 14:50:02]

The majority of the codebase passes reference counted objects as plain pointers.
The caller must guarantee that the object is alive in any case, so can you
please check and convert to plain pointers where possible?

+              scoped_refptr<PrefStore> device_management_prefs,
+              scoped_refptr<PrefStore> extension_prefs,
+              scoped_refptr<PrefStore> command_line_prefs,
+              scoped_refptr<PersistentPrefStore> user_prefs,
+              scoped_refptr<PrefStore> recommended_prefs,
               Profile* profile);
 
+  // Constructor to be used only for CreateIncognitoPrefService.

[Mattias Nissler (ping if slow), 2010/12/20 14:50:02]

After pondering this for a while, I'm now leaning towards a different solution:
Can we just keep scoped_refptrs in PrefService for all our stores and use them
to construct a new PrefService using the above constructor from
CreateIncognitoPrefService? That would also obviate the need for the somewhat
fishy PrefValueStore::Derive().

[battre, 2010/12/21 18:51:59]

Done.

+  PrefService(PrefValueStore* old_pref_value_store,
+              scoped_refptr<PersistentPrefStore> old_user_pref_store,
+              scoped_refptr<PrefStore> incognito_extension_prefs,
+              scoped_refptr<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
@@ skipping 21 matching lines @@
 
   // 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_;
+  scoped_refptr<PersistentPrefStore> user_pref_store_;
 
   // Points to the default pref store we passed to the PrefValueStore.
-  DefaultPrefStore* default_store_;
+  scoped_refptr<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_