src/chrome/browser/extensions/unpacked_installer.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_EXTENSIONS_UNPACKED_INSTALLER_H_
   6 #define CHROME_BROWSER_EXTENSIONS_UNPACKED_INSTALLER_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/bind.h"
  12 #include "base/files/file_path.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "chrome/browser/extensions/extension_installer.h"
  17
  18 class ExtensionService;
  19
  20 namespace extensions {
  21
  22 class Extension;
  23 class RequirementsChecker;
  24
  25 // Installs and loads an unpacked extension. Because internal state needs to be
  26 // held about the instalation process, only one call to Load*() should be made
  27 // per UnpackedInstaller.
  28 // TODO(erikkay): It might be useful to be able to load a packed extension
  29 // (presumably into memory) without installing it.
  30 class UnpackedInstaller
  31     : public base::RefCountedThreadSafe<UnpackedInstaller> {
  32  public:
  33   typedef base::Callback<void(const base::FilePath&, const std::string&)>
  34       OnFailureCallback;
  35
  36   static scoped_refptr<UnpackedInstaller> Create(
  37       ExtensionService* extension_service);
  38
  39   // Loads the extension from the directory |extension_path|, which is
  40   // the top directory of a specific extension where its manifest file lives.
  41   // Errors are reported through ExtensionErrorReporter. On success,
  42   // ExtensionService::AddExtension() is called.
  43   void Load(const base::FilePath& extension_path);
  44
  45   // Loads the extension from the directory |extension_path|;
  46   // for use with command line switch --load-extension=path or
  47   // --load-and-launch-app=path.
  48   // This is equivalent to Load, except that it reads the extension from
  49   // |extension_path| synchronously.
  50   // The return value indicates whether the installation has begun successfully.
  51   // The id of the extension being loaded is returned in |extension_id|.
  52   bool LoadFromCommandLine(const base::FilePath& extension_path,
  53                            std::string* extension_id);
  54
  55   // Allows prompting for plugins to be disabled; intended for testing only.
  56   bool prompt_for_plugins() { return prompt_for_plugins_; }
  57   void set_prompt_for_plugins(bool val) { prompt_for_plugins_ = val; }
  58
  59   // Allows overriding of whether modern manifest versions are required;
  60   // intended for testing.
  61   bool require_modern_manifest_version() const {
  62     return require_modern_manifest_version_;
  63   }
  64   void set_require_modern_manifest_version(bool val) {
  65     require_modern_manifest_version_ = val;
  66   }
  67
  68   void set_on_failure_callback(const OnFailureCallback& callback) {
  69     on_failure_callback_ = callback;
  70   }
  71
  72   void set_be_noisy_on_failure(bool be_noisy_on_failure) {
  73     be_noisy_on_failure_ = be_noisy_on_failure;
  74   }
  75
  76  private:
  77   friend class base::RefCountedThreadSafe<UnpackedInstaller>;
  78
  79   explicit UnpackedInstaller(ExtensionService* extension_service);
  80   virtual ~UnpackedInstaller();
  81
  82   // Must be called from the UI thread.
  83   void ShowInstallPrompt();
  84
  85   // Calls CheckRequirements.
  86   void CallCheckRequirements();
  87
  88   // Callback from RequirementsChecker.
  89   void OnRequirementsChecked(std::vector<std::string> requirement_errors);
  90
  91   // Verifies if loading unpacked extensions is allowed.
  92   bool IsLoadingUnpackedAllowed() const;
  93
  94   // We change the input extension path to an absolute path, on the file thread.
  95   // Then we need to check the file access preference, which needs
  96   // to happen back on the UI thread, so it posts CheckExtensionFileAccess on
  97   // the UI thread. In turn, once that gets the pref, it goes back to the
  98   // file thread with LoadWithFileAccess.
  99   // TODO(yoz): It would be nice to remove this ping-pong, but we need to know
 100   // what file access flags to pass to file_util::LoadExtension.
 101   void GetAbsolutePath();
 102   void CheckExtensionFileAccess();
 103   void LoadWithFileAccess(int flags);
 104
 105   // Notify the frontend that an attempt to retry will not be necessary.
 106   void UnregisterLoadRetryListener();
 107
 108   // Notify the frontend that there was an error loading an extension.
 109   void ReportExtensionLoadError(const std::string& error);
 110
 111   // Called when an unpacked extension has been loaded and installed.
 112   void ConfirmInstall();
 113
 114   // Helper to get the Extension::CreateFlags for the installing extension.
 115   int GetFlags();
 116
 117   // The service we will report results back to.
 118   base::WeakPtr<ExtensionService> service_weak_;
 119
 120   // The pathname of the directory to load from, which is an absolute path
 121   // after GetAbsolutePath has been called.
 122   base::FilePath extension_path_;
 123
 124   // If true and the extension contains plugins, we prompt the user before
 125   // loading.
 126   bool prompt_for_plugins_;
 127
 128   // Whether to require the extension installed to have a modern manifest
 129   // version.
 130   bool require_modern_manifest_version_;
 131
 132   // An optional callback to set in order to be notified of failure.
 133   OnFailureCallback on_failure_callback_;
 134
 135   // Whether or not to be noisy (show a dialog) on failure. Defaults to true.
 136   bool be_noisy_on_failure_;
 137
 138   // Gives access to common methods and data of an extension installer.
 139   ExtensionInstaller installer_;
 140
 141   DISALLOW_COPY_AND_ASSIGN(UnpackedInstaller);
 142 };
 143
 144 }  // namespace extensions
 145
 146 #endif  // CHROME_BROWSER_EXTENSIONS_UNPACKED_INSTALLER_H_