Limit scope of settings API configuration and proxy permission

extensions/browser/extension_pref_value_map.h

 // Copyright 2014 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 EXTENSIONS_BROWSER_EXTENSION_PREF_VALUE_MAP_H_
 #define EXTENSIONS_BROWSER_EXTENSION_PREF_VALUE_MAP_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 77 matching lines @@
                         extensions::ExtensionPrefsScope scope,
                         base::Value* value);
 
   // Remove the extension preference value for |key| of extension |ext_id|.
   // Precondition: the extension must be registered.
   void RemoveExtensionPref(const std::string& ext_id,
                            const std::string& key,
                            extensions::ExtensionPrefsScope scope);
 
   // Returns true if currently no extension with higher precedence controls the
-  // preference.
-  // Note that the this function does does not consider the existence of
+  // preference. If |incognito| is true and the extension does not have
+  // incognito permission, CanExtensionControlPref returns false.
+  // Note that this function does does not consider the existence of
   // policies. An extension is only really able to control a preference if
   // PrefService::Preference::IsExtensionModifiable() returns true as well.
   bool CanExtensionControlPref(const std::string& extension_id,
                                const std::string& pref_key,
                                bool incognito) const;
 
   // Removes all "incognito session only" preference values.
   void ClearAllIncognitoSessionOnlyPreferences();
 
   // Returns true if an extension identified by |extension_id| controls the
   // preference. This means this extension has set a preference value and no
   // other extension with higher precedence overrides it. If |from_incognito|
   // is not NULL, looks at incognito preferences first, and |from_incognito| is
   // set to true if the effective pref value is coming from the incognito
   // preferences, false if it is coming from the normal ones.
   // Note that the this function does does not consider the existence of
   // policies. An extension is only really able to control a preference if
   // PrefService::Preference::IsExtensionModifiable() returns true as well.
   bool DoesExtensionControlPref(const std::string& extension_id,
                                 const std::string& pref_key,
                                 bool* from_incognito) const;
 
-  // Returns the ID of the extension that currently controls this preference.
+  // Returns the ID of the extension that currently controls this preference
+  // for a regular profile. Incognito settings are ignored.
   // Returns an empty string if this preference is not controlled by an
   // extension.
   std::string GetExtensionControllingPref(const std::string& pref_key) const;
 
   // Tell the store it's now fully initialized.
   void NotifyInitializationCompleted();
 
   // Registers the time when an extension |ext_id| is installed.
   void RegisterExtension(const std::string& ext_id,
                          const base::Time& install_time,
-                         bool is_enabled);
+                         bool is_enabled,
+                         bool is_incognito_enabled);
 
   // Deletes all entries related to extension |ext_id|.
   void UnregisterExtension(const std::string& ext_id);
 
   // Hides or makes the extension preference values of the specified extension
   // visible.
   void SetExtensionState(const std::string& ext_id, bool is_enabled);
 
+  // Sets whether the extension has permission to access incognito state.
+  void SetExtensionIncognitoState(const std::string& ext_id,
+                                  bool is_incognito_enabled);
+
   // Adds an observer and notifies it about the currently stored keys.
   void AddObserver(Observer* observer);
 
   void RemoveObserver(Observer* observer);
 
   const base::Value* GetEffectivePrefValue(const std::string& key,
                                            bool incognito,
                                            bool* from_incognito) const;
 
  private:
@@ skipping 37 matching lines @@
   // being destroyed. In tests, it isn't called, so the notification must
   // be done in the destructor. This bit tracks whether it has been done yet.
   bool destroyed_;
 
   ObserverList<Observer, true> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefValueMap);
 };
 
 #endif  // EXTENSIONS_BROWSER_EXTENSION_PREF_VALUE_MAP_H_