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/files/file_path.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "chrome/browser/extensions/extension_installer.h"
  16
  17 class ExtensionService;
  18
  19 namespace extensions {
  20
  21 class Extension;
  22 class RequirementsChecker;
  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   static scoped_refptr<UnpackedInstaller> Create(
  33       ExtensionService* extension_service);
  34
  35   // Loads the extension from the directory |extension_path|, which is
  36   // the top directory of a specific extension where its manifest file lives.
  37   // Errors are reported through ExtensionErrorReporter. On success,
  38   // ExtensionService::AddExtension() is called.
  39   void Load(const base::FilePath& extension_path);
  40
  41   // Loads the extension from the directory |extension_path|;
  42   // for use with command line switch --load-extension=path or
  43   // --load-and-launch-app=path.
  44   // This is equivalent to Load, except that it reads the extension from
  45   // |extension_path| synchronously.
  46   // The return value indicates whether the installation has begun successfully.
  47   // The id of the extension being loaded is returned in |extension_id|.
  48   bool LoadFromCommandLine(const base::FilePath& extension_path,
  49                            std::string* extension_id);
  50
  51   // Allows prompting for plugins to be disabled; intended for testing only.
  52   bool prompt_for_plugins() { return prompt_for_plugins_; }
  53   void set_prompt_for_plugins(bool val) { prompt_for_plugins_ = val; }
  54
  55   // Allows overriding of whether modern manifest versions are required;
  56   // intended for testing.
  57   bool require_modern_manifest_version() const {
  58     return require_modern_manifest_version_;
  59   }
  60   void set_require_modern_manifest_version(bool val) {
  61     require_modern_manifest_version_ = val;
  62   }
  63
  64  private:
  65   friend class base::RefCountedThreadSafe<UnpackedInstaller>;
  66
  67   explicit UnpackedInstaller(ExtensionService* extension_service);
  68   virtual ~UnpackedInstaller();
  69
  70   // Must be called from the UI thread.
  71   void ShowInstallPrompt();
  72
  73   // Calls CheckRequirements.
  74   void CallCheckRequirements();
  75
  76   // Callback from RequirementsChecker.
  77   void OnRequirementsChecked(std::vector<std::string> requirement_errors);
  78
  79   // Verifies if loading unpacked extensions is allowed.
  80   bool IsLoadingUnpackedAllowed() const;
  81
  82   // We change the input extension path to an absolute path, on the file thread.
  83   // Then we need to check the file access preference, which needs
  84   // to happen back on the UI thread, so it posts CheckExtensionFileAccess on
  85   // the UI thread. In turn, once that gets the pref, it goes back to the
  86   // file thread with LoadWithFileAccess.
  87   // TODO(yoz): It would be nice to remove this ping-pong, but we need to know
  88   // what file access flags to pass to extension_file_util::LoadExtension.
  89   void GetAbsolutePath();
  90   void CheckExtensionFileAccess();
  91   void LoadWithFileAccess(int flags);
  92
  93   // Notify the frontend that there was an error loading an extension.
  94   void ReportExtensionLoadError(const std::string& error);
  95
  96   // Called when an unpacked extension has been loaded and installed.
  97   void ConfirmInstall();
  98
  99   // Helper to get the Extension::CreateFlags for the installing extension.
 100   int GetFlags();
 101
 102   // The service we will report results back to.
 103   base::WeakPtr<ExtensionService> service_weak_;
 104
 105   // The pathname of the directory to load from, which is an absolute path
 106   // after GetAbsolutePath has been called.
 107   base::FilePath extension_path_;
 108
 109   // If true and the extension contains plugins, we prompt the user before
 110   // loading.
 111   bool prompt_for_plugins_;
 112
 113   // Whether to require the extension installed to have a modern manifest
 114   // version.
 115   bool require_modern_manifest_version_;
 116
 117   // Gives access to common methods and data of an extension installer.
 118   ExtensionInstaller installer_;
 119
 120   DISALLOW_COPY_AND_ASSIGN(UnpackedInstaller);
 121 };
 122
 123 }  // namespace extensions
 124
 125 #endif  // CHROME_BROWSER_EXTENSIONS_UNPACKED_INSTALLER_H_