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_install_checker.h"
  17
  18 class ExtensionService;
  19
  20 namespace extensions {
  21
  22 class Extension;
  23
  24 // Installs and loads an unpacked extension. Because internal state needs to be
  25 // held about the instalation process, only one call to Load*() should be made
  26 // per UnpackedInstaller.
  27 // TODO(erikkay): It might be useful to be able to load a packed extension
  28 // (presumably into memory) without installing it.
  29 class UnpackedInstaller
  30     : public base::RefCountedThreadSafe<UnpackedInstaller> {
  31  public:
  32   using CompletionCallback = base::Callback<void(const Extension* extension,
  33                                                  const base::FilePath&,
  34                                                  const std::string&)>;
  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_be_noisy_on_failure(bool be_noisy_on_failure) {
  69     be_noisy_on_failure_ = be_noisy_on_failure;
  70   }
  71
  72   void set_completion_callback(const CompletionCallback& callback) {
  73     callback_ = callback;
  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   // Begin management policy and requirements checks.
  86   void StartInstallChecks();
  87
  88   // Callback from ExtensionInstallChecker.
  89   void OnInstallChecksComplete(int failed_checks);
  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   // Passes the extension onto extension service.
 112   void InstallExtension();
 113
 114   // Helper to get the Extension::CreateFlags for the installing extension.
 115   int GetFlags();
 116
 117   const Extension* extension() { return install_checker_.extension().get(); }
 118
 119   // The service we will report results back to.
 120   base::WeakPtr<ExtensionService> service_weak_;
 121
 122   // The pathname of the directory to load from, which is an absolute path
 123   // after GetAbsolutePath has been called.
 124   base::FilePath extension_path_;
 125
 126   // If true and the extension contains plugins, we prompt the user before
 127   // loading.
 128   bool prompt_for_plugins_;
 129
 130   // Whether to require the extension installed to have a modern manifest
 131   // version.
 132   bool require_modern_manifest_version_;
 133
 134   // Whether or not to be noisy (show a dialog) on failure. Defaults to true.
 135   bool be_noisy_on_failure_;
 136
 137   // Checks management policies and requirements before the extension can be
 138   // installed.
 139   ExtensionInstallChecker install_checker_;
 140
 141   CompletionCallback callback_;
 142
 143   DISALLOW_COPY_AND_ASSIGN(UnpackedInstaller);
 144 };
 145
 146 }  // namespace extensions
 147
 148 #endif  // CHROME_BROWSER_EXTENSIONS_UNPACKED_INSTALLER_H_