Disable ExtensionPrefStore for local-state pref store

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.
   typedef std::pair<const Extension*, std::pair<const char*, Value*> >
       ExtensionPrefDetails;
 
+  // The local-state ExtensionPrefStore (shared among all profiles on a
+  // machine), indicated by a NULL |profile|, is prohibited from storing
+  // preferences. Since extensions are installed per profile, allowing them to
+  // control machine-wide settings could lead to unsolvable conflicts, and
+  // should not be necessary anyway.
   ExtensionPrefStore(Profile* profile, PrefNotifier::PrefStoreType type);
   virtual ~ExtensionPrefStore();
 
   // Begins tracking the preference and value an extension wishes to set. This
   // must be called each time an extension API tries to set a preference.
   // The ExtensionPrefStore will take ownership of the |pref_value|.
   virtual void InstallExtensionPref(const Extension* extension,
                                     const char* pref_path,
                                     Value* pref_value);
 
   // Removes an extension and all its preference settings from this PrefStore.
   // This must be called when an extension is uninstalled or disabled.
   virtual void UninstallExtension(const Extension* extension);
 
   // PrefStore methods:
   virtual DictionaryValue* prefs() const { return prefs_.get(); }
 
   virtual PrefReadError ReadPrefs() { return PREF_READ_ERROR_NONE; }
 
  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.
+  // For PrefService injection 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;
 
@@ skipping 57 matching lines @@
   // 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_