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_ 147
