Track permissions granted to extensions in prefs

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>
@@ skipping 105 matching lines @@
   bool IsExtensionAllowedByPolicy(const std::string& extension_id);
 
   // Returns the last value set via SetLastPingDay. If there isn't such a
   // pref, the returned Time will return true for is_null().
   base::Time LastPingDay(const std::string& extension_id) const;
 
   // The time stored is based on the server's perspective of day start time, not
   // the client's.
   void SetLastPingDay(const std::string& extension_id, const base::Time& time);
 
+  // Gets the permissions (|api_permissions|, |host_extent| and |full_access|)
+  // granted to the extension with |extension_id|. |full_access| will be true
+  // if the extension has all effective permissions (like from an NPAPI plugin).
+  // Returns false if the granted permissions haven't been initialized yet.
+  // TODO(jstritar): Refractor the permissions into a class that encapsulates
+  // all granted permissions, can be initialized from preferences or
+  // a manifest file, and can be compared to each other.
+  bool GetGrantedPermissions(const std::string& extension_id,
+                             bool* full_access,
+                             std::set<std::string>* api_permissions,
+                             ExtensionExtent* host_extent);
+
+  // Adds the specified |api_permissions|, |host_extent| and |full_access|
+  // to the granted permissions for extension with |extension_id|.
+  // |full_access| should be set to true if the extension effectively has all
+  // permissions (such as by having an NPAPI plugin).
+  void AddGrantedPermissions(const std::string& extension_id,
+                             const bool full_access,
+                             const std::set<std::string>& api_permissions,
+                             const ExtensionExtent& host_extent);
+
   // Similar to the 2 above, but for the extensions blacklist.
   base::Time BlacklistLastPingDay() const;
   void SetBlacklistLastPingDay(const base::Time& time);
 
   // Returns true if the user enabled this extension to be loaded in incognito
   // mode.
   bool IsIncognitoEnabled(const std::string& extension_id);
   void SetIsIncognitoEnabled(const std::string& extension_id, bool enabled);
 
   // Returns true if the user has chosen to allow this extension to inject
@@ skipping 79 matching lines @@
 
   // Sets the pref |key| for extension |id| to |value|.
   void UpdateExtensionPref(const std::string& id,
                            const std::string& key,
                            Value* value);
 
   // Deletes the pref dictionary for extension |id|.
   void DeleteExtensionPrefs(const std::string& id);
 
   // Reads a boolean pref from |ext| with key |pref_key|.
-  // Return false if the value is false or kPrefBlacklist does not exist.
+  // Return false if the value is false or |pref_key| does not exist.
   bool ReadBooleanFromPref(DictionaryValue* ext, const std::string& pref_key);
 
   // Reads a boolean pref |pref_key| from extension with id |extension_id|.
   bool ReadExtensionPrefBoolean(const std::string& extension_id,
                                 const std::string& pref_key);
 
   // Reads an integer pref from |ext| with key |pref_key|.
   // Return false if the value does not exist.
   bool ReadIntegerFromPref(DictionaryValue* ext, const std::string& pref_key,
                            int* out_value);
 
   // Reads an integer pref |pref_key| from extension with id |extension_id|.
   bool ReadExtensionPrefInteger(const std::string& extension_id,
                                 const std::string& pref_key,
                                 int* out_value);
 
+  // Reads a list pref |pref_key| from extension with id | extension_id|.
+  bool ReadExtensionPrefList(const std::string& extension_id,
+                             const std::string& pref_key,
+                             ListValue** out_value);
+
+  // Reads a list pref |pref_key| as a string set from the extension with
+  // id |extension_id|.
+  bool ReadExtensionPrefStringSet(const std::string& extension_id,
+                                  const std::string& pref_key,
+                                  std::set<std::string>* result);
+
+  // Adds the |added_values| to the value of |pref_key| for the extension
+  // with id |extension_id| (the new value will be the union of the existing
+  // value and |added_values|).
+  void AddToExtensionPrefStringSet(const std::string& extension_id,
+                                   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;
 
   // 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.
@@ skipping 16 matching lines @@
   // Base extensions install directory.
   FilePath install_directory_;
 
   // The URLs of all of the toolstrips.
   URLList shelf_order_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefs);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_