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
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
|
// Copyright 2013 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 EXTENSIONS_BROWSER_EXTENSIONS_BROWSER_CLIENT_H_
#define EXTENSIONS_BROWSER_EXTENSIONS_BROWSER_CLIENT_H_
#include <string>
#include <vector>
#include "base/memory/scoped_ptr.h"
#include "extensions/browser/extension_event_histogram_value.h"
#include "extensions/browser/extension_prefs_observer.h"
#include "extensions/common/view_type.h"
class ExtensionFunctionRegistry;
class PrefService;
namespace base {
class CommandLine;
class FilePath;
class ListValue;
}
namespace content {
class BrowserContext;
class RenderFrameHost;
class WebContents;
}
namespace net {
class NetLog;
class NetworkDelegate;
class URLRequest;
class URLRequestJob;
}
namespace extensions {
class ApiActivityMonitor;
class ComponentExtensionResourceManager;
class Extension;
class ExtensionCache;
class ExtensionError;
class ExtensionHostDelegate;
class ExtensionPrefsObserver;
class ExtensionSystem;
class ExtensionSystemProvider;
class ExtensionWebContentsObserver;
class InfoMap;
class ProcessManagerDelegate;
class RuntimeAPIDelegate;
// Interface to allow the extensions module to make browser-process-specific
// queries of the embedder. Should be Set() once in the browser process.
//
// NOTE: Methods that do not require knowledge of browser concepts should be
// added in ExtensionsClient (extensions/common/extensions_client.h) even if
// they are only used in the browser process.
class ExtensionsBrowserClient {
public:
virtual ~ExtensionsBrowserClient() {}
// Returns true if the embedder has started shutting down.
virtual bool IsShuttingDown() = 0;
// Returns true if extensions have been disabled (e.g. via a command-line flag
// or preference).
virtual bool AreExtensionsDisabled(const base::CommandLine& command_line,
content::BrowserContext* context) = 0;
// Returns true if the |context| is known to the embedder.
virtual bool IsValidContext(content::BrowserContext* context) = 0;
// Returns true if the BrowserContexts could be considered equivalent, for
// example, if one is an off-the-record context owned by the other.
virtual bool IsSameContext(content::BrowserContext* first,
content::BrowserContext* second) = 0;
// Returns true if |context| has an off-the-record context associated with it.
virtual bool HasOffTheRecordContext(content::BrowserContext* context) = 0;
// Returns the off-the-record context associated with |context|. If |context|
// is already off-the-record, returns |context|.
// WARNING: This may create a new off-the-record context. To avoid creating
// another context, check HasOffTheRecordContext() first.
virtual content::BrowserContext* GetOffTheRecordContext(
content::BrowserContext* context) = 0;
// Returns the original "recording" context. This method returns |context| if
// |context| is not incognito.
virtual content::BrowserContext* GetOriginalContext(
content::BrowserContext* context) = 0;
#if defined(OS_CHROMEOS)
// Returns a user id hash from |context| or an empty string if no hash could
// be extracted.
virtual std::string GetUserIdHashFromContext(
content::BrowserContext* context) = 0;
#endif
// Returns true if |context| corresponds to a guest session.
virtual bool IsGuestSession(content::BrowserContext* context) const = 0;
// Returns true if |extension_id| can run in an incognito window.
virtual bool IsExtensionIncognitoEnabled(
const std::string& extension_id,
content::BrowserContext* context) const = 0;
// Returns true if |extension| can see events and data from another
// sub-profile (incognito to original profile, or vice versa).
virtual bool CanExtensionCrossIncognito(
const extensions::Extension* extension,
content::BrowserContext* context) const = 0;
// Returns an URLRequestJob to load an extension resource from the embedder's
// resource bundle (.pak) files. Returns NULL if the request is not for a
// resource bundle resource or if the embedder does not support this feature.
// Used for component extensions. Called on the IO thread.
virtual net::URLRequestJob* MaybeCreateResourceBundleRequestJob(
net::URLRequest* request,
net::NetworkDelegate* network_delegate,
const base::FilePath& directory_path,
const std::string& content_security_policy,
bool send_cors_header) = 0;
// Returns true if the embedder wants to allow a chrome-extension:// resource
// request coming from renderer A to access a resource in an extension running
// in renderer B. For example, Chrome overrides this to provide support for
// webview and dev tools. Called on the IO thread.
virtual bool AllowCrossRendererResourceLoad(net::URLRequest* request,
bool is_incognito,
const Extension* extension,
InfoMap* extension_info_map) = 0;
// Returns the PrefService associated with |context|.
virtual PrefService* GetPrefServiceForContext(
content::BrowserContext* context) = 0;
// Populates a list of ExtensionPrefs observers to be attached to each
// BrowserContext's ExtensionPrefs upon construction. These observers
// are not owned by ExtensionPrefs.
virtual void GetEarlyExtensionPrefsObservers(
content::BrowserContext* context,
std::vector<ExtensionPrefsObserver*>* observers) const = 0;
// Returns the ProcessManagerDelegate shared across all BrowserContexts. May
// return NULL in tests or for simple embedders.
virtual ProcessManagerDelegate* GetProcessManagerDelegate() const = 0;
// Creates a new ExtensionHostDelegate instance.
virtual scoped_ptr<ExtensionHostDelegate> CreateExtensionHostDelegate() = 0;
// Returns true if the client version has updated since the last run. Called
// once each time the extensions system is loaded per browser_context. The
// implementation may wish to use the BrowserContext to record the current
// version for later comparison.
virtual bool DidVersionUpdate(content::BrowserContext* context) = 0;
// Permits an external protocol handler to be launched. See
// ExternalProtocolHandler::PermitLaunchUrl() in Chrome.
virtual void PermitExternalProtocolHandler() = 0;
// Return true if the system is run in forced app mode.
virtual bool IsRunningInForcedAppMode() = 0;
// Returns the embedder's ApiActivityMonitor for |context|. Returns NULL if
// the embedder does not monitor extension API activity.
virtual ApiActivityMonitor* GetApiActivityMonitor(
content::BrowserContext* context) = 0;
// Returns the factory that provides an ExtensionSystem to be returned from
// ExtensionSystem::Get.
virtual ExtensionSystemProvider* GetExtensionSystemFactory() = 0;
// Registers extension functions not belonging to the core extensions APIs.
virtual void RegisterExtensionFunctions(
ExtensionFunctionRegistry* registry) const = 0;
// Registers Mojo services for a RenderFrame.
virtual void RegisterMojoServices(content::RenderFrameHost* render_frame_host,
const Extension* extension) const = 0;
// Creates a RuntimeAPIDelegate responsible for handling extensions
// management-related events such as update and installation on behalf of the
// core runtime API implementation.
virtual scoped_ptr<RuntimeAPIDelegate> CreateRuntimeAPIDelegate(
content::BrowserContext* context) const = 0;
// Returns the manager of resource bundles used in extensions. Returns NULL if
// the manager doesn't exist.
virtual const ComponentExtensionResourceManager*
GetComponentExtensionResourceManager() = 0;
// Propagate a event to all the renderers in every browser context. The
// implementation must be safe to call from any thread.
virtual void BroadcastEventToRenderers(events::HistogramValue histogram_value,
const std::string& event_name,
scoped_ptr<base::ListValue> args) = 0;
// Returns the embedder's net::NetLog.
virtual net::NetLog* GetNetLog() = 0;
// Gets the single ExtensionCache instance shared across the browser process.
virtual ExtensionCache* GetExtensionCache() = 0;
// Indicates whether extension update checks should be allowed.
virtual bool IsBackgroundUpdateAllowed() = 0;
// Indicates whether an extension update which specifies its minimum browser
// version as |min_version| can be installed by the client. Not all extensions
// embedders share the same versioning model, so interpretation of the string
// is left up to the embedder.
virtual bool IsMinBrowserVersionSupported(const std::string& min_version) = 0;
// Embedders can override this function to handle extension errors.
virtual void ReportError(content::BrowserContext* context,
scoped_ptr<ExtensionError> error);
// Returns the ExtensionWebContentsObserver for the given |web_contents|.
virtual ExtensionWebContentsObserver* GetExtensionWebContentsObserver(
content::WebContents* web_contents) = 0;
// Cleans up browser-side state associated with a WebView that is being
// destroyed.
virtual void CleanUpWebView(content::BrowserContext* browser_context,
int embedder_process_id,
int view_instance_id) {}
// Attaches the task manager extension tag to |web_contents|, if needed based
// on |view_type|, so that its corresponding task shows up in the task
// manager.
virtual void AttachExtensionTaskManagerTag(content::WebContents* web_contents,
ViewType view_type) {}
// Returns the single instance of |this|.
static ExtensionsBrowserClient* Get();
// Initialize the single instance.
static void Set(ExtensionsBrowserClient* client);
};
} // namespace extensions
#endif // EXTENSIONS_BROWSER_EXTENSIONS_BROWSER_CLIENT_H_
|