First part to fix Bug 50726 "Save extension list and "winning" prefs from extensions"

chrome/browser/extensions/extension_pref_store.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_PREF_STORE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_PREF_STORE_H_
 #pragma once
 
 #include <list>
 #include <map>
@@ skipping 12 matching lines @@
 class DictionaryValue;
 class Extension;
 class PrefService;
 class Profile;
 class Value;
 
 // This PrefStore keeps track of preferences set by extensions: for example,
 // proxy settings. A stack of relevant extensions is stored in order of
 // their addition to this PrefStore. For each preference, the last-added
 // enabled extension that tries to set it overrules any others.
+//
+// TODO(battre): The ExtensionPrefStore has an issue if it serves for storing
+// extension preferences in the local-state (shared among all profiles on a
+// machine). In this context, there is no meaningful definition of a precedence
+// order as the same extensions can be installed in different profiles.
+// One instance would override the preferences of another instance. Also it is
+// unclear how settings should be removed in this case. For this reason we
+// (pamg, battre) decided to not support the ExtensionPrefStore for local-state.
+// This needs to be enforced by the code.
 class ExtensionPrefStore : public PrefStore,
                            public NotificationObserver {
  public:
   // Maps preference paths to their values.
   typedef std::map<const char*, Value*> PrefValueMap;
 
   // The type passed as Details for an EXTENSION_PREF_CHANGED notification.
   // The nested pairs are <extension, <pref_path, pref_value> >. This is here,
   // rather than in (say) notification_type.h, to keep the dependency on
   // std::pair out of the many places that include notification_type.h.
@@ skipping 22 matching lines @@
  protected:
   // Returns a vector of the extension IDs in the extension_stack_.
   // This should only be accessed by subclasses for unit-testing.
   void GetExtensionIDs(std::vector<std::string>* result);
 
   // Returns the applicable pref service from the profile (if we have one) or
   // the browser's local state. This should only be accessed or overridden by
   // subclasses for unit-testing.
   virtual PrefService* GetPrefService();
 
+  // The following functions delegate to
+  // profile_->GetExtensionsService()->extension_prefs()
+  // and are defined here only for injection in case of unit tests.
+  virtual void PersistExtensionPrecedences(
+      const std::vector<std::string>& precedence);
+  virtual void GetExtensionPrecedences(
+      std::vector<std::string>* precedence) const;
+
  private:
   // Associates an extension with the prefs it sets. Owns the pref values.
   struct ExtensionPrefs {
-    ExtensionPrefs(const Extension* extension, PrefValueMap* values);
+    ExtensionPrefs(const std::string& extension_id, PrefValueMap* values);
     ~ExtensionPrefs();
 
-    const Extension* extension;
+    std::string extension_id;
     PrefValueMap* pref_values;
   };
 
   // A pseudo-stack of extensions and their preferences. Extensions are always
   // added to the head, but may be removed from the middle.
   typedef std::list<ExtensionPrefs*> ExtensionStack;
 
   // Applies the highest-priority extension's setting for the given preference
   // path to the |prefs_| store, or clears the setting there if no extensions
   // wish to control it.
   void UpdateOnePref(const char* path);
 
   // Updates each preference in the key set of the |pref_values| map.
   void UpdatePrefs(const PrefValueMap* pref_values);
 
   // Registers this as an observer for relevant notifications.
   void RegisterObservers();
 
   // Responds to observed notifications.
   void Observe(NotificationType type,
                const NotificationSource& source,
                const NotificationDetails& details);
 
+  // The following functions update the precedence list maintained by
+  // ExtensionPrefs. They are not responsible for updating the |prefs_| cache.
+  // Therefore, they should not be called outside of InstallExtensionPref and
+  // UninstallExtension.
+
+  // Appends |extension_id| to the end of the precedence list. This makes
+  // |extension_id| the extension that overwrites preferences of all other
+  // extensions.
+  void AddPrecedence(const std::string& extension_id);
+
+  // Removes |extension_id| from the precedence list.
+  void RemovePrecedence(const std::string& extension_id);
+
+  // Initializes the extension_stack_ with empty dictionaries for all
+  // extensions registered in the precedence list.
+  void LazyInit();
+
   // A cache of the highest-priority values for each preference that any
   // extension is controlling, for quick read access. Owns the stored values.
   scoped_ptr<DictionaryValue> prefs_;
 
   ExtensionStack extension_stack_;
 
   NotificationRegistrar notification_registrar_;
 
   // Weak reference to the profile whose extensions we're interested in. May be
   // NULL (for the local-state preferences), in which case we watch all
   // extensions.
   Profile* profile_;
 
   // My PrefStore type, assigned by the PrefValueStore.
   PrefNotifier::PrefStoreType type_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefStore);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_PREF_STORE_H_