Introduce incognito preference settings.

chrome/browser/extensions/extension_prefs.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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_
 #pragma once
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/linked_ptr.h"
+#include "base/ref_counted.h"
 #include "base/time.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/extensions/extension.h"
 #include "googleurl/src/gurl.h"
 
 class ExtensionPrefStore;
 
 // Class for managing global and per-extension preferences.
 //
 // This class distinguishes the following kinds of preferences:
@@ skipping 28 matching lines @@
   // application.
   // Do not remove items or re-order this enum as it is used in preferences
   // and histograms.
   enum LaunchType {
     LAUNCH_PINNED,
     LAUNCH_REGULAR,
     LAUNCH_FULLSCREEN,
     LAUNCH_WINDOW
   };
 
+  // Does not assume owner ship of |prefs| and |incognito_prefs|.

[danno, 2010/12/22 10:48:21]

nit: s/owner ship/ownership/

[Mattias Nissler (ping if slow), 2010/12/22 12:09:03]

s/owner ship/ownership/

[battre, 2010/12/22 18:34:53]

Done.

[battre, 2010/12/22 18:34:53]

Done.

   explicit ExtensionPrefs(PrefService* prefs,
+                          PrefService* incognito_prefs,
                           const FilePath& root_dir,
-                          ExtensionPrefStore* extension_pref_store);
+                          ExtensionPrefStore* extension_pref_store,
+                          ExtensionPrefStore* incognito_pref_store);

[Mattias Nissler (ping if slow), 2010/12/22 12:09:03]

It worries me that we need the incognito_prefs pointer here as well. The pref
service should only be used for keeping stuff that needs to be persisted.

How about the following design change: We change the ExtensionPrefStore
interface to keep not only the effective extension controlled prefs, but push
all of them there.  Figuring out what is the effective one could then be
implemented in the ExtensionPrefStore. That would mean that we don't need to go
to the PrefService to find out about all currently configured extension
controlled prefs, and the incognito PrefService pointer here could go away.

[battre, 2010/12/22 18:34:53]

Will do this in the next patch set of this CL.

   ~ExtensionPrefs();
 
   // Returns a copy of the Extensions prefs.
   // TODO(erikkay) Remove this so that external consumers don't need to be
   // aware of the internal structure of the preferences.
   DictionaryValue* CopyCurrentExtensions();
 
   // Returns true if the specified extension has an entry in prefs
   // and its killbit is on.
   bool IsExtensionKilled(const std::string& id);
@@ skipping 181 matching lines @@
   // of the extension is available.
   void SetUpdateUrlData(const std::string& extension_id,
                         const std::string& data);
   std::string GetUpdateUrlData(const std::string& extension_id);
 
   // Sets a preference value that is controlled by the extension. In other
   // words, this is not a pref value *about* the extension but something
   // global the extension wants to override.
   void SetExtensionControlledPref(const std::string& extension_id,
                                   const std::string& pref_key,
+                                  bool incognito,
                                   Value* value);
 
   static void RegisterUserPrefs(PrefService* prefs);
 
   // The underlying PrefService.
   PrefService* pref_service() const { return prefs_; }
 
  protected:
   // For unit testing. Enables injecting an artificial clock that is used
   // to query the current time, when an extension is installed.
@@ skipping 52 matching lines @@
                                    const std::string& pref_key,
                                    const std::set<std::string>& added_values);
 
   // Ensures and returns a mutable dictionary for extension |id|'s prefs.
   DictionaryValue* GetOrCreateExtensionPref(const std::string& id);
 
   // Same as above, but returns NULL if it doesn't exist.
   DictionaryValue* GetExtensionPref(const std::string& id) const;
 
   // Returns the dictionary of preferences controlled by the specified extension
-  // or NULL if unknown. All entries in the dictionary contain non-expanded
+  // or creates a new one. All entries in the dictionary contain non-expanded
   // paths.
-  DictionaryValue* GetExtensionControlledPrefs(const std::string& id) const;
+  DictionaryValue* GetExtensionControlledPrefs(const std::string& id,
+                                               bool incognito) const;
 
   // Serializes the data and schedules a persistent save via the |PrefService|.
   // Additionally fires a PREF_CHANGED notification with the top-level
   // |kExtensionsPref| path set.
   // TODO(andybons): Switch this to EXTENSION_PREF_CHANGED to be more granular.
   // TODO(andybons): Use a ScopedPrefUpdate to update observers on changes to
   // the mutable extension dictionary.
   void SavePrefsAndNotify();
 
   // Checks if kPrefBlacklist is set to true in the DictionaryValue.
@@ skipping 12 matching lines @@
   // in a later Chrome version.
   void FixMissingPrefs(const ExtensionIdSet& extension_ids);
 
   // Installs the persistent extension preferences into |prefs_|'s extension
   // pref store.
   void InitPrefStore();
 
   // Returns the extension controlled preference value of the extension that was
   // installed most recently.
   const Value* GetWinningExtensionControlledPrefValue(
-      const std::string& key) const;
+      const std::string& key, bool incognito) const;
 
   // Executes UpdatePrefStore for all |pref_keys|.
   void UpdatePrefStore(const PrefKeySet& pref_keys);
 
   // Finds the most recently installed extension that defines a preference
   // for |pref_key|, then stores its value in the PrefValueStore's extension
   // pref store and sends notifications to observers in case the value changed.
-  void UpdatePrefStore(const std::string& pref_key);
+  void UpdatePrefStore(const std::string& pref_key, bool incognito);
 
   // Retrieves a list of preference keys that the specified extension
   // intends to manage. Keys are always appended, |out| is not cleared.
   void GetExtensionControlledPrefKeys(const std::string& extension_id,
                                       PrefKeySet *out) const;
 
-  // The pref service specific to this set of extension prefs.
+  // The pref service specific to this set of extension prefs. Owned by profile.
   PrefService* prefs_;
+  PrefService* incognito_prefs_;
 
   // Base extensions install directory.
   FilePath install_directory_;
 
   // Used to manipulate extension preferences.
-  ExtensionPrefStore* pref_store_;
+  scoped_refptr<ExtensionPrefStore> pref_store_;
+  // Shared with PrefValueStore of |incognito_prefs_|.
+  scoped_refptr<ExtensionPrefStore> incognito_pref_store_;
 
   // The URLs of all of the toolstrips.
   URLList shelf_order_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefs);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_