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
|
// 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_RENDERER_SCRIPT_INJECTION_MANAGER_H_
#define EXTENSIONS_RENDERER_SCRIPT_INJECTION_MANAGER_H_
#include <stdint.h>
#include <map>
#include <set>
#include <string>
#include <vector>
#include "base/functional/callback.h"
#include "base/memory/raw_ptr.h"
#include "base/scoped_observation.h"
#include "extensions/common/mojom/frame.mojom.h"
#include "extensions/common/mojom/host_id.mojom-forward.h"
#include "extensions/common/mojom/run_location.mojom-shared.h"
#include "extensions/common/user_script.h"
#include "extensions/renderer/script_injection.h"
#include "extensions/renderer/user_script_set_manager.h"
namespace content {
class RenderFrame;
}
namespace extensions {
// The ScriptInjectionManager manages extensions injecting scripts into frames
// via both content/user scripts and tabs.executeScript(). It is responsible for
// maintaining any pending injections awaiting permission or the appropriate
// load point, and injecting them when ready.
class ScriptInjectionManager : public UserScriptSetManager::Observer {
public:
explicit ScriptInjectionManager(
UserScriptSetManager* user_script_set_manager);
ScriptInjectionManager(const ScriptInjectionManager&) = delete;
ScriptInjectionManager& operator=(const ScriptInjectionManager&) = delete;
virtual ~ScriptInjectionManager();
// Notifies that a new render view has been created.
void OnRenderFrameCreated(content::RenderFrame* render_frame);
// Removes pending injections of the unloaded extension.
void OnExtensionUnloaded(const std::string& extension_id);
// Handle the ExecuteCode extension message.
void HandleExecuteCode(mojom::ExecuteCodeParamsPtr params,
mojom::LocalFrame::ExecuteCodeCallback callback,
content::RenderFrame* render_frame);
void ExecuteDeclarativeScript(content::RenderFrame* render_frame,
int tab_id,
const ExtensionId& extension_id,
const std::string& script_id,
const GURL& url);
void set_activity_logging_enabled(bool enabled) {
activity_logging_enabled_ = enabled;
}
private:
// A RenderFrameObserver implementation which watches the various render
// frames in order to notify the ScriptInjectionManager of different
// document load states and IPCs.
class RFOHelper;
using FrameStatusMap = std::map<content::RenderFrame*, mojom::RunLocation>;
using ScriptInjectionVector = std::vector<std::unique_ptr<ScriptInjection>>;
// Notifies that an injection has been finished or permission has been
// handled.
void OnInjectionStatusUpdated(ScriptInjection::InjectionStatus status,
ScriptInjection* injection);
// Notifies that an injection has been finished.
void OnInjectionFinished(ScriptInjection* injection);
// Handle the GrantInjectionPermission extension message.
void OnPermitScriptInjectionHandled(ScriptInjection* injection);
// UserScriptSetManager::Observer implementation.
void OnUserScriptsUpdated(const mojom::HostID& changed_host) override;
// Notifies that an RFOHelper should be removed.
void RemoveObserver(RFOHelper* helper);
// Invalidate any pending tasks associated with |frame|.
void InvalidateForFrame(content::RenderFrame* frame);
// Starts the process to inject appropriate scripts into |frame|.
void StartInjectScripts(content::RenderFrame* frame,
mojom::RunLocation run_location);
// Actually injects the scripts into |frame|.
void InjectScripts(content::RenderFrame* frame,
mojom::RunLocation run_location);
// Try to inject and store injection if it has not finished.
void TryToInject(std::unique_ptr<ScriptInjection> injection,
mojom::RunLocation run_location,
ScriptsRunInfo* scripts_run_info);
// The map of active web frames to their corresponding statuses. The
// RunLocation of the frame corresponds to the last location that has ran.
FrameStatusMap frame_statuses_;
// The frames currently being injected into, so long as that frame is valid.
std::set<content::RenderFrame*> active_injection_frames_;
// The collection of RFOHelpers.
std::vector<std::unique_ptr<RFOHelper>> rfo_helpers_;
// The set of UserScripts associated with extensions. Owned by the Dispatcher.
raw_ptr<UserScriptSetManager, ExperimentalRenderer> user_script_set_manager_;
// Pending injections which are waiting for either the proper run location or
// user consent.
ScriptInjectionVector pending_injections_;
// Running injections which are waiting for async callbacks from blink.
ScriptInjectionVector running_injections_;
// Whether or not dom activity should be logged for scripts injected.
bool activity_logging_enabled_ = false;
base::ScopedObservation<UserScriptSetManager, UserScriptSetManager::Observer>
user_script_set_manager_observation_{this};
};
} // namespace extensions
#endif // EXTENSIONS_RENDERER_SCRIPT_INJECTION_MANAGER_H_
|
