Extension white and force lists (set by policy) should have priority over auto-updated Google black…

chrome/browser/extensions/extension_prefs.h

 // Copyright (c) 2012 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_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 110 matching lines @@
   void OnExtensionUninstalled(const std::string& extension_id,
                               const Extension::Location& location,
                               bool external_uninstall);
 
   // Called to change the extension's state when it is enabled/disabled.
   void SetExtensionState(const std::string& extension_id, Extension::State);
 
   // Returns all installed extensions
   void GetExtensions(ExtensionIdSet* out);
 
-  // Returns all installed extensions from |extension_prefs|. This is exposed
-  // for ProtectedPrefsWatcher because it needs access to the extension ID list
-  // before the ExtensionService is initialized.
-  static ExtensionIdSet GetExtensionsFrom(
-      const base::DictionaryValue* extension_prefs);
+  // Returns all installed extensions from extension preferences provided by
+  // |pref_service|. This is exposed for ProtectedPrefsWatcher because it needs
+  // access to the extension ID list before the ExtensionService is initialized.
+  static ExtensionIdSet GetExtensionsFrom(const PrefService* pref_service);
 
   // Getter and setter for browser action visibility.
   bool GetBrowserActionVisibility(const Extension* extension);
   void SetBrowserActionVisibility(const Extension* extension,
      bool visible);
 
   // Did the extension ask to escalate its permission during an upgrade?
   bool DidExtensionEscalatePermissions(const std::string& id);
 
   // If |did_escalate| is true, the preferences for |extension| will be set to
@@ skipping 20 matching lines @@
   // Returns extension path based on extension ID, or empty FilePath on error.
   FilePath GetExtensionPath(const std::string& extension_id);
 
   // Returns base extensions install directory.
   const FilePath& install_directory() const { return install_directory_; }
 
   // Updates the prefs based on the blacklist.
   void UpdateBlacklist(const std::set<std::string>& blacklist_set);
 
   // Based on extension id, checks prefs to see if it is blacklisted.
-  bool IsExtensionBlacklisted(const std::string& id);
+  bool IsExtensionBlacklisted(const std::string& id) const;
+
+  // Same as above, but can be called when no class instance is available.
+  static bool IsExtensionBlacklisted(const std::string& extension_id,

[Matt Perry, 2012/08/07 19:50:04]

static methods should all be before non-static. you'll have to update the
comment, too.

[qfel, 2012/08/13 16:03:01]

Done.

Is this some kind of extension-code-specific rule?

+                                     const PrefService* pref_service);
 
   // Based on extension id, checks prefs to see if it is orphaned.
   bool IsExtensionOrphaned(const std::string& id);
 
   // Whether the user has acknowledged an external extension.
   bool IsExternalExtensionAcknowledged(const std::string& extension_id);
   void AcknowledgeExternalExtension(const std::string& extension_id);
 
   // Whether the user has acknowledged a blacklisted extension.
   bool IsBlacklistedExtensionAcknowledged(const std::string& extension_id);
@@ skipping 294 matching lines @@
                                        std::string* out_value) const OVERRIDE;
 
   // Converts absolute paths in the pref to paths relative to the
   // install_directory_.
   void MakePathsRelative();
 
   // Converts internal relative paths to be absolute. Used for export to
   // consumers who expect full paths.
   void MakePathsAbsolute(base::DictionaryValue* dict);
 
-  // Reads a boolean pref from |ext| with key |pref_key|.
-  // Return false if the value is false or |pref_key| does not exist.
-  static bool ReadBooleanFromPref(const base::DictionaryValue* ext,
-                                  const std::string& pref_key);
-
-  // Reads an integer pref from |ext| with key |pref_key|.
-  // Return false if the value does not exist.
-  static bool ReadIntegerFromPref(const base::DictionaryValue* ext,
-                                  const std::string& pref_key,
-                                  int* out_value);
-
   // Interprets the list pref, |pref_key| in |extension_id|'s preferences, as a
   // URLPatternSet. The |valid_schemes| specify how to parse the URLPatterns.
   bool ReadExtensionPrefURLPatternSet(const std::string& extension_id,
                                       const std::string& pref_key,
                                       URLPatternSet* result,
                                       int valid_schemes);
 
   // Converts |new_value| to a list of strings and sets the |pref_key| pref
   // belonging to |extension_id|.
   void SetExtensionPrefURLPatternSet(const std::string& extension_id,
@@ skipping 13 matching lines @@
 
   // Returns a dictionary for extension |id|'s prefs or NULL if it doesn't
   // exist.
   const base::DictionaryValue* GetExtensionPref(const std::string& id) const;
 
   // Loads the preferences controlled by the specified extension from their
   // dictionary and sets them in the |pref_value_map_|.
   void LoadExtensionControlledPrefs(const std::string& id,
                                     ExtensionPrefsScope scope);
 
-  // Checks if kPrefBlacklist is set to true in the DictionaryValue.
-  // Return false if the value is false or kPrefBlacklist does not exist.
-  // This is used to decide if an extension is blacklisted.
-  static bool IsBlacklistBitSet(const base::DictionaryValue* ext);
-
   // Fix missing preference entries in the extensions that are were introduced
   // in a later Chrome version.
   void FixMissingPrefs(const ExtensionIdSet& extension_ids);
 
   // Installs the persistent extension preferences into |prefs_|'s extension
   // pref store. Does nothing if |extensions_disabled| is true.
   void InitPrefStore(bool extensions_disabled);
 
   // Migrates the permissions data in the pref store.
   void MigratePermissions(const ExtensionIdSet& extension_ids);
 
   // Checks whether there is a state pref for the extension and if so, whether
   // it matches |check_state|.
   bool DoesExtensionHaveState(const std::string& id,
                               Extension::State check_state) const;
 
+  // Helper function for GetInstalledExtensionInfo and
+  // GetInstalledExtensionsInfo.
+  ExtensionInfo* GetInstalledExtensionInfoImpl(
+      DictionaryValue* extension_data,
+      DictionaryValue::key_iterator extension_id) const;
+
   // The pref service specific to this set of extension prefs. Owned by profile.
   PrefService* prefs_;
 
   // Base extensions install directory.
   FilePath install_directory_;
 
   // Weak pointer, owned by Profile.
   ExtensionPrefValueMap* extension_pref_value_map_;
 
   // Contains all the logic for handling the order for various extension
   // properties.
   scoped_ptr<ExtensionSorting> extension_sorting_;
 
   scoped_refptr<ContentSettingsStore> content_settings_store_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefs);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_