Moved CrxInstaller and CrxInstallerError into extensions namespace

chrome/browser/extensions/crx_installer.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_CRX_INSTALLER_H_
 #define CHROME_BROWSER_EXTENSIONS_CRX_INSTALLER_H_
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/version.h"
 #include "chrome/browser/extensions/crx_installer_error.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/sandboxed_unpacker.h"
 #include "chrome/browser/extensions/webstore_installer.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/string_ordinal.h"
 #include "chrome/common/web_apps.h"
 
 class ExtensionService;
 class SkBitmap;
 
 namespace extensions {
 class ExtensionUpdaterTest;
-}
 
 // This class installs a crx file into a profile.
 //
 // Installing a CRX is a multi-step process, including unpacking the crx,
 // validating it, prompting the user, and installing. Since many of these
 // steps must occur on the file thread, this class contains a copy of all data
 // necessary to do its job. (This also minimizes external dependencies for
 // easier testing).
 //
 // Lifetime management:
 //
 // This class is ref-counted by each call it makes to itself on another thread,
 // and by UtilityProcessHost.
 //
 // Additionally, we hold a reference to our own client so that it lives at least
 // long enough to receive the result of unpacking.
 //
 // IMPORTANT: Callers should keep a reference to a CrxInstaller while they are
 // working with it, eg:
 //
 // scoped_refptr<CrxInstaller> installer(new CrxInstaller(...));
 // installer->set_foo();
 // installer->set_bar();
 // installer->InstallCrx(...);
 class CrxInstaller
-    : public extensions::SandboxedUnpackerClient,
+    : public SandboxedUnpackerClient,
       public ExtensionInstallPrompt::Delegate {
  public:
   // Used in histograms; do not change order.
   enum OffStoreInstallAllowReason {
     OffStoreInstallDisallowed,
     OffStoreInstallAllowedFromSettingsPage,
     OffStoreInstallAllowedBecausePref,
     OffStoreInstallAllowedInTest,
     NumOffStoreInstallAllowReasons
   };
 
   // Extensions will be installed into frontend->install_directory(),
   // then registered with |frontend|. Any install UI will be displayed
   // using |client|. Pass NULL for |client| for silent install
   static scoped_refptr<CrxInstaller> Create(
       ExtensionService* frontend,
       ExtensionInstallPrompt* client);
 
   // Same as the previous method, except use the |approval| to bypass the
   // prompt. Note that the caller retains ownership of |approval|.
   static scoped_refptr<CrxInstaller> Create(
       ExtensionService* frontend,
       ExtensionInstallPrompt* client,
-      const extensions::WebstoreInstaller::Approval* approval);
+      const WebstoreInstaller::Approval* approval);
 
   // Install the crx in |source_file|.
   void InstallCrx(const FilePath& source_file);
 
   // Convert the specified user script into an extension and install it.
   void InstallUserScript(const FilePath& source_file,
                          const GURL& download_url);
 
   // Convert the specified web app into an extension and install it.
   void InstallWebApp(const WebApplicationInfo& web_app);
 
   // Overridden from ExtensionInstallPrompt::Delegate:
   virtual void InstallUIProceed() OVERRIDE;
   virtual void InstallUIAbort(bool user_initiated) OVERRIDE;
 
   int creation_flags() const { return creation_flags_; }
   void set_creation_flags(int val) { creation_flags_ = val; }
 
   const GURL& download_url() const { return download_url_; }
   void set_download_url(const GURL& val) { download_url_ = val; }
 
   const FilePath& source_file() const { return source_file_; }
 
-  extensions::Extension::Location install_source() const {
+  Extension::Location install_source() const {
     return install_source_;
   }
-  void set_install_source(extensions::Extension::Location source) {
+  void set_install_source(Extension::Location source) {
     install_source_ = source;
   }
 
   const std::string& expected_id() const { return expected_id_; }
   void set_expected_id(const std::string& val) { expected_id_ = val; }
 
   void set_expected_version(const Version& val) {
     expected_version_.reset(new Version(val));
   }
 
   bool delete_source() const { return delete_source_; }
   void set_delete_source(bool val) { delete_source_ = val; }
 
   bool allow_silent_install() const { return allow_silent_install_; }
   void set_allow_silent_install(bool val) { allow_silent_install_ = val; }
 
   bool is_gallery_install() const {
-    return (creation_flags_ & extensions::Extension::FROM_WEBSTORE) > 0;
+    return (creation_flags_ & Extension::FROM_WEBSTORE) > 0;
   }
   void set_is_gallery_install(bool val) {
     if (val)
-      creation_flags_ |= extensions::Extension::FROM_WEBSTORE;
+      creation_flags_ |= Extension::FROM_WEBSTORE;
     else
-      creation_flags_ &= ~extensions::Extension::FROM_WEBSTORE;
+      creation_flags_ &= ~Extension::FROM_WEBSTORE;
   }
 
   // The original download URL should be set when the WebstoreInstaller is
   // tracking the installation. The WebstoreInstaller uses this URL to match
   // failure notifications to the extension.
   const GURL& original_download_url() const { return original_download_url_; }
   void set_original_download_url(const GURL& url) {
     original_download_url_ = url;
   }
 
@@ skipping 24 matching lines @@
 
   void set_page_ordinal(const StringOrdinal& page_ordinal) {
     page_ordinal_ = page_ordinal;
   }
 
   bool did_handle_successfully() const { return did_handle_successfully_; }
 
   Profile* profile() { return profile_; }
 
  private:
-  friend class extensions::ExtensionUpdaterTest;
+  friend class ExtensionUpdaterTest;
   friend class ExtensionCrxInstallerTest;
 
   CrxInstaller(base::WeakPtr<ExtensionService> frontend_weak,
                ExtensionInstallPrompt* client,
-               const extensions::WebstoreInstaller::Approval* approval);
+               const WebstoreInstaller::Approval* approval);
   virtual ~CrxInstaller();
 
   // Converts the source user script to an extension.
   void ConvertUserScriptOnFileThread();
 
   // Converts the source web app to an extension.
   void ConvertWebAppOnFileThread(const WebApplicationInfo& web_app);
 
   // Called after OnUnpackSuccess as a last check to see whether the install
   // should complete.
-  CrxInstallerError AllowInstall(const extensions::Extension* extension);
+  CrxInstallerError AllowInstall(const Extension* extension);
 
   // SandboxedUnpackerClient
   virtual void OnUnpackFailure(const string16& error_message) OVERRIDE;
   virtual void OnUnpackSuccess(const FilePath& temp_dir,
                                const FilePath& extension_dir,
                                const base::DictionaryValue* original_manifest,
-                               const extensions::Extension* extension) OVERRIDE;
+                               const Extension* extension) OVERRIDE;
 
   // Returns true if we can skip confirmation because the install was
   // whitelisted.
   bool CanSkipConfirmation();
 
   // Runs on the UI thread. Confirms with the user (via ExtensionInstallPrompt)
   // that it is OK to install this extension.
   void ConfirmInstall();
 
   // Runs on File thread. Install the unpacked extension into the profile and
   // notify the frontend.
   void CompleteInstall();
 
   // Result reporting.
   void ReportFailureFromFileThread(const CrxInstallerError& error);
   void ReportFailureFromUIThread(const CrxInstallerError& error);
   void ReportSuccessFromFileThread();
   void ReportSuccessFromUIThread();
-  void NotifyCrxInstallComplete(const extensions::Extension* extension);
+  void NotifyCrxInstallComplete(const Extension* extension);
 
   // The file we're installing.
   FilePath source_file_;
 
   // The URL the file was downloaded from.
   GURL download_url_;
 
   // The directory extensions are installed to.
   FilePath install_directory_;
 
   // The location the installation came from (bundled with Chromium, registry,
   // manual install, etc). This metadata is saved with the installation if
   // successful. Defaults to INTERNAL.
-  extensions::Extension::Location install_source_;
+  Extension::Location install_source_;
 
   // Indicates whether the user has already approved the extension to be
   // installed. If true, |expected_manifest_| and |expected_id_| must match
   // those of the CRX.
   bool approved_;
 
   // For updates, external and webstore installs we have an ID we're expecting
   // the extension to contain.
   std::string expected_id_;
 
@@ skipping 20 matching lines @@
   // The download URL, before redirects, if this is a gallery install.
   GURL original_download_url_;
 
   // Whether to create an app shortcut after successful installation. This is
   // set based on the user's selection in the UI and can only ever be true for
   // apps.
   bool create_app_shortcut_;
 
   // The extension we're installing. We own this and either pass it off to
   // ExtensionService on success, or delete it on failure.
-  scoped_refptr<const extensions::Extension> extension_;
+  scoped_refptr<const Extension> extension_;
 
   // The ordinal of the NTP apps page |extension_| will be shown on.
   StringOrdinal page_ordinal_;
 
   // A parsed copy of the unmodified original manifest, before any
   // transformations like localization have taken place.
   scoped_ptr<base::DictionaryValue> original_manifest_;
 
   // If non-empty, contains the current version of the extension we're
   // installing (for upgrades).
@@ skipping 54 matching lines @@
   // there was an error; if there was an error that rejects installation we
   // still consider the installation 'handled'.
   bool did_handle_successfully_;
 
   // Whether we should record an oauth2 grant upon successful install.
   bool record_oauth2_grant_;
 
   DISALLOW_COPY_AND_ASSIGN(CrxInstaller);
 };
 
+}  // namespace extensions
+
 #endif  // CHROME_BROWSER_EXTENSIONS_CRX_INSTALLER_H_