1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_EXTENSIONS_EXTENSIONS_SERVICE_H_
#define CHROME_BROWSER_EXTENSIONS_EXTENSIONS_SERVICE_H_
#include <vector>
#include "base/file_path.h"
#include "base/message_loop.h"
#include "base/ref_counted.h"
#include "base/task.h"
#include "chrome/browser/extensions/extension.h"
typedef std::vector<Extension*> ExtensionList;
class ExtensionsServiceBackend;
class UserScriptMaster;
// Interface for the frontend to implement. Typically, this will be
// ExtensionsService, but it can also be a test harness.
class ExtensionsServiceFrontendInterface
: public base::RefCountedThreadSafe<ExtensionsServiceFrontendInterface> {
public:
virtual ~ExtensionsServiceFrontendInterface(){}
// The message loop to invoke the frontend's methods on.
virtual MessageLoop* GetMessageLoop() = 0;
// Called when loading an extension fails.
virtual void OnExtensionLoadError(const std::string& message) = 0;
// Called with results from LoadExtensionsFromDirectory(). The frontend
// takes ownership of the list.
virtual void OnExtensionsLoadedFromDirectory(ExtensionList* extensions) = 0;
// Install the extension file at extension_path.
virtual void InstallExtension(const FilePath& extension_path) = 0;
// Called when installing an extension fails.
virtual void OnExtensionInstallError(const std::string& message) = 0;
// Called with results from InstallExtension().
virtual void OnExtensionInstalled(FilePath path) = 0;
};
// Manages installed and running Chromium extensions.
class ExtensionsService : public ExtensionsServiceFrontendInterface {
public:
ExtensionsService(const FilePath& profile_directory,
UserScriptMaster* user_script_master);
~ExtensionsService();
// Gets the list of currently installed extensions.
const ExtensionList* extensions() const {
return &extensions_;
}
// Initialize and start all installed extensions.
bool Init();
// ExtensionsServiceFrontendInterface
virtual MessageLoop* GetMessageLoop();
virtual void OnExtensionLoadError(const std::string& message);
virtual void OnExtensionsLoadedFromDirectory(ExtensionList* extensions);
virtual void InstallExtension(const FilePath& extension_path);
virtual void OnExtensionInstallError(const std::string& message);
virtual void OnExtensionInstalled(FilePath path);
// The name of the file that the current active version number is stored in.
static const char* kCurrentVersionFileName;
private:
// The name of the directory inside the profile where extensions are
// installed to.
static const char* kInstallDirectoryName;
// The message loop for the thread the ExtensionsService is running on.
MessageLoop* message_loop_;
// The backend that will do IO on behalf of this instance.
scoped_refptr<ExtensionsServiceBackend> backend_;
// The current list of installed extensions.
ExtensionList extensions_;
// The full path to the directory where extensions are installed.
FilePath install_directory_;
// The user script master for this profile.
scoped_refptr<UserScriptMaster> user_script_master_;
DISALLOW_COPY_AND_ASSIGN(ExtensionsService);
};
// Implements IO for the ExtensionsService.
// TODO(aa): Extract an interface out of this for testing the frontend, once the
// frontend has significant logic to test.
class ExtensionsServiceBackend
: public base::RefCountedThreadSafe<ExtensionsServiceBackend> {
public:
ExtensionsServiceBackend(){};
// Loads extensions from a directory. The extensions are assumed to be
// unpacked in directories that are direct children of the specified path.
// Errors are reported through OnExtensionLoadError(). On completion,
// OnExtensionsLoadedFromDirectory() is called with any successfully loaded
// extensions.
bool LoadExtensionsFromDirectory(
const FilePath &path,
scoped_refptr<ExtensionsServiceFrontendInterface> frontend);
// Install the extension file at extension_path to install_dir.
// ReportExtensionInstallError is called on error.
// ReportExtensionInstalled is called on success.
bool InstallExtension(
const FilePath& extension_path,
const FilePath& install_dir,
scoped_refptr<ExtensionsServiceFrontendInterface> frontend);
private:
// Notify a frontend that there was an error loading an extension.
void ReportExtensionLoadError(ExtensionsServiceFrontendInterface* frontend,
const FilePath& path,
const std::string& error);
// Notify a frontend that extensions were loaded.
void ReportExtensionsLoaded(ExtensionsServiceFrontendInterface* frontend,
ExtensionList* extensions);
// Notify a frontend that there was an error installing an extension.
void ReportExtensionInstallError(ExtensionsServiceFrontendInterface* frontend,
const FilePath& path,
const std::string& error);
// Notify a frontend that extensions were installed.
void ReportExtensionInstalled(ExtensionsServiceFrontendInterface* frontend,
FilePath path);
// Read the manifest from the front of the extension file.
DictionaryValue* ReadManifest(const FilePath& extension_path,
scoped_refptr<ExtensionsServiceFrontendInterface> frontend);
// Check that the version to be installed is > the current installed
// extension.
bool CheckCurrentVersion(const FilePath& extension_path,
const std::string& version,
const FilePath& dest_dir,
scoped_refptr<ExtensionsServiceFrontendInterface> frontend);
// Unzip the extension into |dest_dir|.
bool UnzipExtension(const FilePath& extension_path,
const FilePath& dest_dir,
scoped_refptr<ExtensionsServiceFrontendInterface> frontend);
// Install the extension dir by moving it from |source| to |dest| safely.
bool InstallDirSafely(const FilePath& extension_path,
const FilePath& source, const FilePath& dest,
scoped_refptr<ExtensionsServiceFrontendInterface> frontend);
// Update the CurrentVersion file in |dest_dir| to |version|.
bool SetCurrentVersion(const FilePath& extension_path,
const FilePath& dest_dir,
std::string version,
scoped_refptr<ExtensionsServiceFrontendInterface> frontend);
// The name of a temporary directory to install an extension into for
// validation before finalizing install.
static const char* kTempExtensionName;
DISALLOW_COPY_AND_ASSIGN(ExtensionsServiceBackend);
};
#endif // CHROME_BROWSER_EXTENSIONS_EXTENSIONS_SERVICE_H_
|
