Move Extension 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>
@@ skipping 34 matching lines @@
 //       PrefValueStore::extension_prefs(), which this class populates and
 //       maintains as the underlying extensions change.
 class ExtensionPrefs : public ExtensionContentSettingsStore::Observer,
                        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<ExtensionInfo> > ExtensionsInfo;
+  typedef std::vector<linked_ptr<extensions::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 Extension* extension,
-                            Extension::State initial_state,
+  void OnExtensionInstalled(const extensions::Extension* extension,
+                            extensions::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 Extension::Location& location,
+                              const extensions::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);
+  void SetExtensionState(const std::string& extension_id,
+      extensions::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 Extension* extension);
-  void SetBrowserActionVisibility(const Extension* extension, bool visible);
+  bool GetBrowserActionVisibility(const extensions::Extension* extension);
+  void SetBrowserActionVisibility(const extensions::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 Extension* extension,
-                                          bool did_escalate);
+  void SetDidExtensionEscalatePermissions(
+      const extensions::Extension* extension,
+      bool did_escalate);
 
   // Getter and setters for disabled reason.
-  Extension::DisableReason GetDisableReason(const std::string& extension_id);
+  extensions::Extension::DisableReason GetDisableReason(
+      const std::string& extension_id);
   void SetDisableReason(const std::string& extension_id,
-                        Extension::DisableReason disable_reason);
+                        extensions::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 Extension* extension);
+  void UpdateManifest(const extensions::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);
 
   // Is the extension with |extension_id| allowed by policy (checking both
   // whitelist and blacklist).
   bool IsExtensionAllowedByPolicy(const std::string& extension_id,
-                                  Extension::Location location) const;
+      extensions::Extension::Location location) const;
 
   // Checks if extensions are blacklisted by default, by policy. When true, this
   // means that even extensions without an ID should be blacklisted (e.g.
   // from the command line, or when loaded as an unpacked extension).
   // IsExtensionAllowedByPolicy() also takes 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().
@@ skipping 75 matching lines @@
   // |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 Extension* extension,
+      const extensions::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.
-  ExtensionInfo* GetInstalledExtensionInfo(const std::string& extension_id);
+  extensions::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 189 matching lines @@
   // 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;
+                              extensions::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<ExtensionContentSettingsStore> content_settings_store_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefs);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_