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
18class ExtensionService;
19
20namespace extensions {
21
22class Extension;
23class 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.
30class 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