Introduce per-tab preferences service.

chrome/browser/prefs/pref_service.h

 // 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
 
@@ skipping 128 matching lines @@
   static PrefService* CreatePrefService(const FilePath& pref_filename,
                                         PrefStore* extension_pref_store,
                                         bool async);
 
   // 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);
 
+  // Creates a per-tab copy of the pref service that shares most pref stores
+  // and allows WebKit-related preferences to be overridden on per-tab basis.
+  PrefService* CreatePrefServiceWithPerTabPrefStore();
+
   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 131 matching lines @@
   // preference is not registered.
   const Preference* FindPreference(const char* pref_name) const;
 
   bool ReadOnly() const;
 
   // SyncableService getter.
   // TODO(zea): Have PrefService implement SyncableService directly.
   SyncableService* GetSyncableService();
 
  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.
+  // Construct a new pref service. This constructor is what
+  // CreatePrefService() ends up calling and what is used for unit tests.
   PrefService(PrefStore* managed_platform_prefs,
               PrefStore* managed_cloud_prefs,
               PrefStore* extension_prefs,
               PrefStore* command_line_prefs,
               PersistentPrefStore* user_prefs,
               PrefStore* recommended_platform_prefs,
               PrefStore* recommended_cloud_prefs,
-              DefaultPrefStore* default_store,
               bool async);

[Mattias Nissler (ping if slow), 2011/11/17 18:44:39]

newline before comment.

[mnaganov (inactive), 2011/11/17 19:53:32]

Done.

-
-  // 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_;
+  // An overloaded version that clones and specializes value store.
+  // Used for CreateIncognito and Create...PerTabPrefStore.
+  PrefService(PrefValueStore* source_store,
+              PrefStore* managed_platform_prefs,
+              PrefStore* managed_cloud_prefs,
+              PrefStore* extension_prefs,
+              PrefStore* command_line_prefs,
+              PersistentPrefStore* user_prefs,
+              PrefStore* recommended_platform_prefs,
+              PrefStore* recommended_cloud_prefs,
+              DefaultPrefStore* default_store);
 
  private:
   class PreferencePathComparator {
    public:
     bool operator() (Preference* lhs, Preference* rhs) const {
       return lhs->name() < rhs->name();
     }
   };
   typedef std::set<Preference*, PreferencePathComparator> PreferenceSet;
 
   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;
 
   // Give access to ReportUserPrefChanged() and GetMutableUserPref().
   friend class subtle::ScopedUserPrefUpdateBase;
 
-  // Construct an incognito version of the pref service. Use
-  // CreateIncognitoPrefService() instead of calling this constructor directly.
-  PrefService(const PrefService& original,
-              PrefStore* incognito_extension_prefs);
-
   // Sends notification of a changed preference. This needs to be called by
   // a ScopedUserPrefUpdate if a DictionaryValue or ListValue is changed.
   void ReportUserPrefChanged(const std::string& key);
 
   // 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,
                                content::NotificationObserver* obs);
@@ skipping 19 matching lines @@
   // Used to set the value of dictionary or list values in the user pref store.
   // This will create a dictionary or list if one does not exist in the user
   // pref store. This method returns NULL only if you're requesting an
   // unregistered pref or a non-dict/non-list pref.
   // |type| may only be Values::TYPE_DICTIONARY or Values::TYPE_LIST and
   // |path| must point to a registered preference of type |type|.
   // Ownership of the returned value remains at the user pref store.
   base::Value* GetMutableUserPref(const char* path,
                                   base::Value::Type type);
 
-  // The PrefValueStore provides prioritized preference values. It is created
-  // and owned by this PrefService. Subclasses may access it for unit testing.
-  scoped_ptr<PrefValueStore> pref_value_store_;
+  // The PrefNotifier handles registering and notifying preference observers.
+  // It is created and owned by this PrefService.
+  scoped_ptr<PrefNotifierImpl> pref_notifier_;
 
   // Pref Stores and profile that we passed to the PrefValueStore.
   scoped_refptr<PersistentPrefStore> user_pref_store_;
   scoped_refptr<DefaultPrefStore> default_store_;
 
   // 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_;
 
   // The model associator that maintains the links with the sync db.
   scoped_ptr<PrefModelAssociator> pref_sync_associator_;
 
+  // The PrefValueStore provides prioritized preference values. It is created
+  // and owned by this PrefService. Subclasses may access it for unit testing.
+  scoped_ptr<PrefValueStore> pref_value_store_;
+
   DISALLOW_COPY_AND_ASSIGN(PrefService);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_SERVICE_H_