WIP: Introduce per-TabContents PrefService.

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 125 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-TabContents pref service derived from this PrefService. The
+  // new PrefService will share all PrefStores with the base PrefService, except
+  // for user prefs. Also, it manages a separate set of registered prefs.
+  PrefService* CreateTabContentsPrefService();
+
   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.
-  PrefService(PrefStore* managed_platform_prefs,
-              PrefStore* managed_cloud_prefs,
-              PrefStore* extension_prefs,
-              PrefStore* command_line_prefs,
+  // Construct a new pref service. This constructor is what CreatePrefService()
+  // ends up calling. It's also used for unit tests.
+  PrefService(PrefValueStore* pref_value_store,
               PersistentPrefStore* user_prefs,
-              PrefStore* recommended_platform_prefs,
-              PrefStore* recommended_cloud_prefs,
               DefaultPrefStore* default_store,
+              PrefNotifierImpl* pref_notifier,
               bool async);
 
   // 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:
   class PreferencePathComparator {
    public:
@@ skipping 10 matching lines @@
   // 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, NotificationObserver* obs);
   virtual void RemovePrefObserver(const char* path, NotificationObserver* obs);
@@ skipping 37 matching lines @@
   // of registered preferences are.
   mutable PreferenceSet prefs_;
 
   // The model associator that maintains the links with the sync db.
   scoped_ptr<PrefModelAssociator> pref_sync_associator_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefService);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_SERVICE_H_