Moved ExtensionPrefs and related into extensions namespace

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_
 #pragma once
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/memory/linked_ptr.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/content_settings/content_settings_store.h"
 #include "chrome/browser/extensions/extension_prefs_scope.h"
 #include "chrome/browser/extensions/extension_scoped_prefs.h"
 #include "chrome/browser/extensions/management_policy.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/url_pattern_set.h"
 #include "chrome/common/string_ordinal.h"
 
 class ExtensionPrefValueMap;
 class ExtensionSorting;
 class PrefService;
 class URLPatternSet;
 
 namespace extensions {
+class ExtensionPrefsUninstallExtension;
 struct ExtensionOmniboxSuggestion;
-}
 
 // Class for managing global and per-extension preferences.
 //
 // This class distinguishes the following kinds of preferences:
 // - global preferences:
 //       internal state for the extension system in general, not associated
 //       with an individual extension, such as lastUpdateTime.
 // - per-extension preferences:
 //       meta-preferences describing properties of the extension like
 //       installation time, whether the extension is enabled, etc.
 // - extension controlled preferences:
 //       browser preferences that an extension controls. For example, an
 //       extension could use the proxy API to specify the browser's proxy
 //       preference. Extension-controlled preferences are stored in
 //       PrefValueStore::extension_prefs(), which this class populates and
 //       maintains as the underlying extensions change.
-class ExtensionPrefs : public extensions::ContentSettingsStore::Observer,
-                       public extensions::ManagementPolicy::Provider,
+class ExtensionPrefs : public ContentSettingsStore::Observer,
+                       public ManagementPolicy::Provider,
                        public ExtensionScopedPrefs {
  public:
   // Key name for a preference that keeps track of per-extension settings. This
   // is a dictionary object read from the Preferences file, keyed off of
   // extension ids.
   static const char kExtensionsPref[];
 
-  typedef std::vector<linked_ptr<extensions::ExtensionInfo> > ExtensionsInfo;
+  typedef std::vector<linked_ptr<ExtensionInfo> > ExtensionsInfo;
 
   // Vector containing identifiers for preferences.
   typedef std::set<std::string> PrefKeySet;
 
   // Vector containing identifiers for extensions.
   typedef std::vector<std::string> ExtensionIdSet;
 
   // This enum is used for the launch type the user wants to use for an
   // application.
   // Do not remove items or re-order this enum as it is used in preferences
@@ skipping 37 matching lines @@
 
   // Get the order that the browser actions appear in the toolbar.
   std::vector<std::string> GetToolbarOrder();
 
   // Set the order that the browser actions appear in the toolbar.
   void SetToolbarOrder(const std::vector<std::string>& extension_ids);
 
   // Called when an extension is installed, so that prefs get created.
   // If |page_ordinal| is an invalid ordinal, then a page will be found
   // for the App.
-  void OnExtensionInstalled(const extensions::Extension* extension,
-                            extensions::Extension::State initial_state,
+  void OnExtensionInstalled(const Extension* extension,
+                            Extension::State initial_state,
                             bool from_webstore,
                             const StringOrdinal& page_ordinal);
 
   // Called when an extension is uninstalled, so that prefs get cleaned up.
   void OnExtensionUninstalled(const std::string& extension_id,
-                              const extensions::Extension::Location& location,
+                              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,
-      extensions::Extension::State);
+  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);
 
   // Getter and setter for browser action visibility.
-  bool GetBrowserActionVisibility(const extensions::Extension* extension);
-  void SetBrowserActionVisibility(const extensions::Extension* extension,
+  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
   // require the install warning when the user tries to enable.
   void SetDidExtensionEscalatePermissions(
-      const extensions::Extension* extension,
+      const Extension* extension,
       bool did_escalate);
 
   // Getter and setters for disabled reason.
-  extensions::Extension::DisableReason GetDisableReason(
+  Extension::DisableReason GetDisableReason(
       const std::string& extension_id);
   void SetDisableReason(const std::string& extension_id,
-                        extensions::Extension::DisableReason disable_reason);
+                        Extension::DisableReason disable_reason);
   void RemoveDisableReason(const std::string& extension_id);
 
   // Returns the version string for the currently installed extension, or
   // the empty string if not found.
   std::string GetVersionString(const std::string& extension_id);
 
   // Re-writes the extension manifest into the prefs.
   // Called to change the extension's manifest when it's re-localized.
-  void UpdateManifest(const extensions::Extension* extension);
+  void UpdateManifest(const Extension* extension);
 
   // 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);
 
@@ skipping 28 matching lines @@
   void SetAppNotificationClientId(const std::string& extension_id,
                                   const std::string& oauth_client_id);
 
   // Whether app notifications are disabled for the given app.
   bool IsAppNotificationDisabled(const std::string& extension_id) const;
   void SetAppNotificationDisabled(const std::string& extension_id, bool value);
 
   // ManagementPolicy::Provider
   // These methods apply admin policy to extensions.
   virtual std::string GetDebugPolicyProviderName() const OVERRIDE;
-  virtual bool UserMayLoad(const extensions::Extension* extension,
+  virtual bool UserMayLoad(const Extension* extension,
                            string16* error) const OVERRIDE;
-  virtual bool UserMayModifySettings(const extensions::Extension* extension,
+  virtual bool UserMayModifySettings(const Extension* extension,
                                      string16* error) const OVERRIDE;
-  virtual bool MustRemainEnabled(const extensions::Extension* extension,
+  virtual bool MustRemainEnabled(const Extension* extension,
                                  string16* error) const OVERRIDE;
 
   // Checks if extensions are blacklisted by default, by policy.
   // The ManagementPolicy::Provider methods also take this into account, and
   // should be used instead when the extension ID is known.
   bool ExtensionsBlacklistedByDefault() const;
 
   // 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;
@@ skipping 14 matching lines @@
 
   // A bit we use for determining if we should send the "days since active"
   // ping. A value of true means the item has been active (launched) since the
   // last update check.
   bool GetActiveBit(const std::string& extension_id);
   void SetActiveBit(const std::string& extension_id, bool active);
 
   // Returns the granted permission set for the extension with |extension_id|,
   // and NULL if no preferences were found for |extension_id|.
   // This passes ownership of the returned set to the caller.
-  extensions::PermissionSet* GetGrantedPermissions(
-      const std::string& extension_id);
+  PermissionSet* GetGrantedPermissions(const std::string& extension_id);
 
   // Adds |permissions| to the granted permissions set for the extension with
   // |extension_id|. The new granted permissions set will be the union of
   // |permissions| and the already granted permissions.
   void AddGrantedPermissions(const std::string& extension_id,
-                             const extensions::PermissionSet* permissions);
+                             const PermissionSet* permissions);
 
   // As above, but subtracts the given |permissions| from the granted set.
   void RemoveGrantedPermissions(const std::string& extension_id,
-                                const extensions::PermissionSet* permissions);
+                                const PermissionSet* permissions);
 
   // Gets the active permission set for the specified extension. This may
   // differ from the permissions in the manifest due to the optional
   // permissions API. This passes ownership of the set to the caller.
-  extensions::PermissionSet* GetActivePermissions(
-      const std::string& extension_id);
+  PermissionSet* GetActivePermissions(const std::string& extension_id);
 
   // Sets the active |permissions| for the extension with |extension_id|.
   void SetActivePermissions(const std::string& extension_id,
-                            const extensions::PermissionSet* permissions);
+                            const PermissionSet* permissions);
 
   // Returns the list of events that the given extension has registered for.
   std::set<std::string> GetRegisteredEvents(const std::string& extension_id);
   void SetRegisteredEvents(const std::string& extension_id,
                            const std::set<std::string>& events);
 
   // Adds a filter to an event.
   void AddFilterToEvent(const std::string& event_name,
                         const std::string& extension_id,
                         const DictionaryValue* filter);
 
   // Removes a filter from an event.
   void RemoveFilterFromEvent(const std::string& event_name,
                              const std::string& extension_id,
                              const DictionaryValue* filter);
 
   // Returns the dictionary of event filters that the given extension has
   // registered.
   const DictionaryValue* GetFilteredEvents(
       const std::string& extension_id) const;
 
   // Controls the omnibox default suggestion as set by the extension.
-  extensions::ExtensionOmniboxSuggestion GetOmniboxDefaultSuggestion(
+  ExtensionOmniboxSuggestion GetOmniboxDefaultSuggestion(
       const std::string& extension_id);
   void SetOmniboxDefaultSuggestion(
       const std::string& extension_id,
-      const extensions::ExtensionOmniboxSuggestion& suggestion);
+      const ExtensionOmniboxSuggestion& suggestion);
 
   // 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
   // scripts into pages with file URLs.
   bool AllowFileAccess(const std::string& extension_id);
   void SetAllowFileAccess(const std::string& extension_id, bool allow);
   bool HasAllowFileAccessSetting(const std::string& extension_id) const;
 
   // Get the launch type preference.  If no preference is set, return
   // |default_pref_value|.
   LaunchType GetLaunchType(const std::string& extension_id,
                            LaunchType default_pref_value);
 
   void SetLaunchType(const std::string& extension_id, LaunchType launch_type);
 
   // Find the right launch container based on the launch type.
   // If |extension|'s prefs do not have a launch type set, then
   // use |default_pref_value|.
   extension_misc::LaunchContainer GetLaunchContainer(
-      const extensions::Extension* extension,
+      const Extension* extension,
       LaunchType default_pref_value);
 
   // Saves ExtensionInfo for each installed extension with the path to the
   // version directory and the location. Blacklisted extensions won't be saved
   // and neither will external extensions the user has explicitly uninstalled.
   // Caller takes ownership of returned structure.
   ExtensionsInfo* GetInstalledExtensionsInfo();
 
   // Returns the ExtensionInfo from the prefs for the given extension. If the
   // extension is not present, NULL is returned.
-  extensions::ExtensionInfo* GetInstalledExtensionInfo(
-      const std::string& extension_id);
+  ExtensionInfo* GetInstalledExtensionInfo(const std::string& extension_id);
 
   // We've downloaded an updated .crx file for the extension, but are waiting
   // for idle time to install it.
   void SetIdleInstallInfo(const std::string& extension_id,
                           const FilePath& crx_path,
                           const std::string& version,
                           const base::Time& fetch_time);
 
   // Removes any idle install information we have for the given |extension_id|.
   // Returns true if there was info to remove; false otherwise.
@@ skipping 74 matching lines @@
   // bookmark.
   bool IsFromBookmark(const std::string& extension_id) const;
 
   // Helper method to acquire the installation time of an extension.
   // Returns base::Time() if the installation time could not be parsed or
   // found.
   base::Time GetInstallTime(const std::string& extension_id) const;
 
   static void RegisterUserPrefs(PrefService* prefs);
 
-  extensions::ContentSettingsStore* content_settings_store() {
+  ContentSettingsStore* content_settings_store() {
     return content_settings_store_.get();
   }
 
   // The underlying PrefService.
   PrefService* pref_service() const { return prefs_; }
 
   // The underlying ExtensionSorting.
   ExtensionSorting* extension_sorting() const {
     return extension_sorting_.get();
   }
 
   // Describes the URLs that are able to install extensions. See
   // prefs::kExtensionAllowedInstallSites for more information.
   URLPatternSet GetAllowedInstallSites();
 
  protected:
   // For unit testing. Enables injecting an artificial clock that is used
   // to query the current time, when an extension is installed.
   virtual base::Time GetCurrentTime() const;
 
  private:
   friend class ExtensionPrefsUninstallExtension;  // Unit test.
 
   // extensions::ContentSettingsStore::Observer methods:
-  virtual void OnContentSettingChanged(
-      const std::string& extension_id,
-      bool incognito) OVERRIDE;
+  virtual void OnContentSettingChanged(const std::string& extension_id,
+                                       bool incognito) OVERRIDE;
 
   // ExtensionScopedPrefs methods:
   virtual void UpdateExtensionPref(const std::string& id,
                                    const std::string& key,
                                    base::Value* value) OVERRIDE;
   virtual void DeleteExtensionPrefs(const std::string& id) OVERRIDE;
   virtual bool ReadExtensionPrefBoolean(
       const std::string& extension_id,
       const std::string& pref_key) const OVERRIDE;
   virtual bool ReadExtensionPrefInteger(const std::string& extension_id,
@@ skipping 34 matching lines @@
                                       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,
                                      const std::string& pref_key,
                                      const URLPatternSet& new_value);
 
   // Interprets |pref_key| in |extension_id|'s preferences as an
   // PermissionSet, and passes ownership of the set to the caller.
-  extensions::PermissionSet* ReadExtensionPrefPermissionSet(
-      const std::string& extension_id,
-      const std::string& pref_key);
+  PermissionSet* ReadExtensionPrefPermissionSet(const std::string& extension_id,
+                                                const std::string& pref_key);
 
   // Converts the |new_value| to its value and sets the |pref_key| pref
   // belonging to |extension_id|.
-  void SetExtensionPrefPermissionSet(
-      const std::string& extension_id,
-      const std::string& pref_key,
-      const extensions::PermissionSet* new_value);
+  void SetExtensionPrefPermissionSet(const std::string& extension_id,
+                                     const std::string& pref_key,
+                                     const PermissionSet* new_value);
 
   // 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(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,
-                              extensions::Extension::State check_state) const;
+                              Extension::State check_state) 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<extensions::ContentSettingsStore> content_settings_store_;
+  scoped_refptr<ContentSettingsStore> content_settings_store_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefs);
 };
 
+}  // namespace extensions
+
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_