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);
 
-  // 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);

[Mattias Nissler (ping if slow), 2011/11/17 20:08:13]

Oh, I had totally missed that there's now a second constructor, sorry. Then
again, why do we need it? Looking at the code it seems easy to just have one
that takes all arguments?

[mnaganov (inactive), 2011/11/18 11:20:45]

The difference between them is that the first one creates a new PrefValueStore,
and the other uses CloneAndSpecialize from the existing store. The alternative
solution that was in your original change -- passing a ready PrefValueStore into
a constructor doesn't work well for TestingPrefServiceBase class which derives
from PrefService. We need to create instances of default pref store, pref
notifier and sync associator and to pass them both to PrefService itself and to
PrefValueStore (as extracting them back from PrefValueStore requires casts that
you were against of).

In your CL, you dealt only with factory functions where you can introduce local
variables:

PrefService* CreatePrefService(...) {
  PrefNotifier* pref_notifier = new PrefNotifierImpl(...);
  return new PrefService(new PrefValueStore(..., pref_notifier, ...),
pref_notifier)
}

But I don't know any elegant way to reuse the same pref notifier in a derived
constructor. I can't even use derived class fields for binding an instance
reference because the base class constructor must be called first. What I need
to be able is to write something like this:

TestingPrefServiceBase(...)
  : PrefService(new PrefValueStore(..., pref_notifier = new PrefNotifierImpl(),
...), ..., pref_notifier, ...) {

Which isn't possible.

[mnaganov (inactive), 2011/11/18 11:24:48]

In theory, we can exploit multiple inheritance here, by using a helper class
which will stand the first in the list of base classes for
TestingPrefServiceBase and will have fields for objects that need to be passed
both to PrefValueStore and PrefService. But this seems to be ugly as well, isn't
it?

[Mattias Nissler (ping if slow), 2011/11/18 12:01:37]

Ah, I remember :) TestingPrefServiceBase was originally created to work around
this exact problem: Passing the same newly-allocated object to two different
initializers in the constructor. TestingPrefService instantiates the PrefStores
and then passes them on to the TestingPrefServiceBase ctor which saves local
pointers as well as using them for the PrefService ctor call. So I believe you
could do exactly the same for the pointers you need multiple times? Just pass in
the PrefValueStorePointer that has PrefNotifierImpl already set and then again
in a separate ctor parameter? Maybe that doesn't work nicely though since
PrefNotifierImpl currently requires the PrefService pointer on construction.
Alternatively, maybe we can just make a PrefValueStore::set_notifier() call, so
the PrefService ctor can instantiate PrefNotifierImpl and install it on
PrefValueStore? I hope I'm not missing something again.

[mnaganov (inactive), 2011/11/18 14:35:05]

I have discovered a nice trick that in constructor initializers of a derived
class you can reference already initialized fields of base class, which made
possible writing TestingPrefServiceBase constructor that passes same instances
both to PrefService and PrefValueStore. Hope you will enjoy it!

 
  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_