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
|
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef EXTENSIONS_BROWSER_RENDERER_STARTUP_HELPER_H_
#define EXTENSIONS_BROWSER_RENDERER_STARTUP_HELPER_H_
#include <map>
#include <optional>
#include <set>
#include "base/compiler_specific.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/singleton.h"
#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
#include "components/keyed_service/core/keyed_service.h"
#include "content/public/browser/render_process_host_creation_observer.h"
#include "content/public/browser/render_process_host_observer.h"
#include "extensions/common/extension_id.h"
#include "extensions/common/mojom/renderer.mojom.h"
#include "extensions/common/mojom/renderer_host.mojom.h"
#include "mojo/public/cpp/bindings/associated_receiver_set.h"
#include "mojo/public/cpp/bindings/associated_remote.h"
#include "mojo/public/cpp/bindings/pending_associated_receiver.h"
#include "mojo/public/cpp/bindings/pending_associated_remote.h"
namespace content {
class BrowserContext;
class RenderProcessHost;
} // namespace content
namespace extensions {
class Extension;
// Informs renderers about extensions-related data (loaded extensions, available
// functions, etc.) when they start. Sends this information to both extension
// and non-extension renderers, as the non-extension renderers may have content
// scripts. Lives on the UI thread. Shared between incognito and non-incognito
// browser contexts. Also handles sending the loaded, unloaded, and activated
// extension messages, since these can *only* be sent once the process is
// initialized.
// TODO(devlin): "StartupHelper" is no longer sufficient to describe the entire
// behavior of this class.
class RendererStartupHelper : public KeyedService,
public content::RenderProcessHostCreationObserver,
public content::RenderProcessHostObserver,
public mojom::RendererHost {
public:
// This class sends messages to all renderers started for `browser_context`.
explicit RendererStartupHelper(content::BrowserContext* browser_context);
RendererStartupHelper(const RendererStartupHelper&) = delete;
RendererStartupHelper& operator=(const RendererStartupHelper&) = delete;
~RendererStartupHelper() override;
// content::RenderProcessHostCreationObserver:
void OnRenderProcessHostCreated(
content::RenderProcessHost* process_host) override;
// content::RenderProcessHostObserver:
void RenderProcessExited(
content::RenderProcessHost* host,
const content::ChildProcessTerminationInfo& info) override;
void RenderProcessHostDestroyed(content::RenderProcessHost* host) override;
// mojom::RendererHost:
void AddAPIActionToActivityLog(const std::optional<ExtensionId>& extension_id,
const std::string& call_name,
base::Value::List args,
const std::string& extra) override;
void AddEventToActivityLog(const std::optional<ExtensionId>& extension_id,
const std::string& call_name,
base::Value::List args,
const std::string& extra) override;
void AddDOMActionToActivityLog(const ExtensionId& extension_id,
const std::string& call_name,
base::Value::List args,
const GURL& url,
const std::u16string& url_title,
int32_t call_type) override;
void GetMessageBundle(const ExtensionId& extension_id,
GetMessageBundleCallback callback) override;
// Sends a message to the specified `process` activating the given extension
// once the process is initialized. OnExtensionLoaded should have already been
// called for the extension.
void ActivateExtensionInProcess(const Extension& extension,
content::RenderProcessHost* process);
// Sends a message to all initialized processes to [un]load the given
// extension. We have explicit calls for these (rather than using an
// ExtensionRegistryObserver) because this needs to happen before other
// initialization which might rely on the renderers being notified.
void OnExtensionUnloaded(const Extension& extension);
void OnExtensionLoaded(const Extension& extension);
// Sends a message to all renderers to update the developer mode.
void OnDeveloperModeChanged(bool in_developer_mode);
// Sends a message to all renderers to update user scripts API allowed state
// for an extension.
void OnUserScriptsAllowedChanged(const ExtensionId& extension_id,
bool allowed);
// Sets properties for the user script world of the given `world_id` for
// the given `extension` in all applicable renderers.
void SetUserScriptWorldProperties(const Extension& extension,
mojom::UserScriptWorldInfoPtr world_info);
// Notifies renderers to clear any properties for the user script world
// associated with the given `extension` and `world_id`.
void ClearUserScriptWorldProperties(
const Extension& extension,
const std::optional<std::string>& world_id);
// Returns mojom::Renderer* corresponding to `process`. This would return
// nullptr when it's called before `process` is inserted to
// `process_mojo_map_` or after it's deleted. Note that the callers should
// pass a valid content::RenderProcessHost*.
mojom::Renderer* GetRenderer(content::RenderProcessHost* process);
static void BindForRenderer(
int process_id,
mojo::PendingAssociatedReceiver<mojom::RendererHost> receiver);
// Flushes any pending Mojo calls for all tracked render processes.
void FlushAllForTesting();
protected:
// Provide ability for tests to override.
virtual mojo::PendingAssociatedRemote<mojom::Renderer> BindNewRendererRemote(
content::RenderProcessHost* process);
private:
friend class RendererStartupHelperTest;
friend class RendererStartupHelperInterceptor;
// Initializes the specified process, informing it of system state and loaded
// extensions.
void InitializeProcess(content::RenderProcessHost* process);
// Untracks the given process.
void UntrackProcess(content::RenderProcessHost* process);
// Return the browser context associated with the renderer.
content::BrowserContext* GetRendererBrowserContext();
// TODO(hferreiro): can be nullptr as in ChromeExtensionMessageFilter?
raw_ptr<content::BrowserContext> browser_context_; // Not owned.
// Tracks the set of loaded extensions and the processes they are loaded in.
std::map<ExtensionId,
std::set<raw_ptr<content::RenderProcessHost, SetExperimental>>>
extension_process_map_;
// The set of ids for extensions that are active in a process that has not
// been initialized. The activation message will be sent the process is
// initialized.
std::map<content::RenderProcessHost*, std::set<ExtensionId>>
pending_active_extensions_;
// A map of render processes to mojo remotes. Being in this
// map means that have had the initial batch of IPC messages
// sent, including the set of loaded extensions. Further messages that
// activate, load, or unload extensions should not be sent until after this
// happens.
std::map<content::RenderProcessHost*, mojo::AssociatedRemote<mojom::Renderer>>
process_mojo_map_;
// Associate each renderer with the RenderProcessHost id.
mojo::AssociatedReceiverSet<mojom::RendererHost, int> receivers_;
};
// Factory for RendererStartupHelpers. Declared here because this header is
// rarely included and it's probably cheaper to put it here than to make the
// compiler generate another object file.
class RendererStartupHelperFactory : public BrowserContextKeyedServiceFactory {
public:
RendererStartupHelperFactory(const RendererStartupHelperFactory&) = delete;
RendererStartupHelperFactory& operator=(const RendererStartupHelperFactory&) =
delete;
static RendererStartupHelper* GetForBrowserContext(
content::BrowserContext* context);
static RendererStartupHelperFactory* GetInstance();
private:
friend struct base::DefaultSingletonTraits<RendererStartupHelperFactory>;
RendererStartupHelperFactory();
~RendererStartupHelperFactory() override;
// BrowserContextKeyedServiceFactory implementation:
std::unique_ptr<KeyedService> BuildServiceInstanceForBrowserContext(
content::BrowserContext* profile) const override;
content::BrowserContext* GetBrowserContextToUse(
content::BrowserContext* context) const override;
bool ServiceIsCreatedWithBrowserContext() const override;
};
} // namespace extensions
#endif // EXTENSIONS_BROWSER_RENDERER_STARTUP_HELPER_H_
|
