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
|
// Copyright 2017 the V8 project 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 V8_TEST_INSPECTOR_PROTOCOL_ISOLATE_DATA_H_
#define V8_TEST_INSPECTOR_PROTOCOL_ISOLATE_DATA_H_
#include <map>
#include <memory>
#include "include/v8-array-buffer.h"
#include "include/v8-inspector.h"
#include "include/v8-local-handle.h"
#include "include/v8-locker.h"
#include "include/v8-script.h"
#include "src/base/optional.h"
namespace v8 {
class Context;
class Isolate;
class ObjectTemplate;
class StartupData;
namespace internal {
class TaskRunner;
enum WithInspector : bool { kWithInspector = true, kNoInspector = false };
class InspectorIsolateData : public v8_inspector::V8InspectorClient {
public:
class SetupGlobalTask {
public:
virtual ~SetupGlobalTask() = default;
virtual void Run(v8::Isolate* isolate,
v8::Local<v8::ObjectTemplate> global) = 0;
};
using SetupGlobalTasks = std::vector<std::unique_ptr<SetupGlobalTask>>;
InspectorIsolateData(const InspectorIsolateData&) = delete;
InspectorIsolateData& operator=(const InspectorIsolateData&) = delete;
InspectorIsolateData(TaskRunner* task_runner,
SetupGlobalTasks setup_global_tasks,
v8::StartupData* startup_data,
WithInspector with_inspector);
static InspectorIsolateData* FromContext(v8::Local<v8::Context> context);
~InspectorIsolateData() override {
// Enter the isolate before destructing this InspectorIsolateData, so that
// destructors that run before the Isolate's destructor still see it as
// entered. Use a v8::Locker, in case the thread destroying the isolate is
// not the last one that entered it.
locker_.emplace(isolate());
isolate()->Enter();
}
v8::Isolate* isolate() const { return isolate_.get(); }
TaskRunner* task_runner() const { return task_runner_; }
// Setting things up.
int CreateContextGroup();
V8_NODISCARD bool CreateContext(int context_group_id,
v8_inspector::StringView name);
void ResetContextGroup(int context_group_id);
v8::Local<v8::Context> GetDefaultContext(int context_group_id);
int GetContextGroupId(v8::Local<v8::Context> context);
void RegisterModule(v8::Local<v8::Context> context,
std::vector<uint16_t> name,
v8::ScriptCompiler::Source* source);
// Working with V8Inspector api.
int ConnectSession(int context_group_id,
const v8_inspector::StringView& state,
v8_inspector::V8Inspector::Channel* channel);
std::vector<uint8_t> DisconnectSession(int session_id);
void SendMessage(int session_id, const v8_inspector::StringView& message);
void BreakProgram(int context_group_id,
const v8_inspector::StringView& reason,
const v8_inspector::StringView& details);
void Stop(int session_id);
void SchedulePauseOnNextStatement(int context_group_id,
const v8_inspector::StringView& reason,
const v8_inspector::StringView& details);
void CancelPauseOnNextStatement(int context_group_id);
void AsyncTaskScheduled(const v8_inspector::StringView& name, void* task,
bool recurring);
void AsyncTaskStarted(void* task);
void AsyncTaskFinished(void* task);
v8_inspector::V8StackTraceId StoreCurrentStackTrace(
const v8_inspector::StringView& description);
void ExternalAsyncTaskStarted(const v8_inspector::V8StackTraceId& parent);
void ExternalAsyncTaskFinished(const v8_inspector::V8StackTraceId& parent);
void AddInspectedObject(int session_id, v8::Local<v8::Value> object);
// Test utilities.
void SetCurrentTimeMS(double time);
void SetMemoryInfo(v8::Local<v8::Value> memory_info);
void SetLogConsoleApiMessageCalls(bool log);
void SetLogMaxAsyncCallStackDepthChanged(bool log);
void SetAdditionalConsoleApi(v8_inspector::StringView api_script);
void SetMaxAsyncTaskStacksForTest(int limit);
void DumpAsyncTaskStacksStateForTest();
void FireContextCreated(v8::Local<v8::Context> context, int context_group_id,
v8_inspector::StringView name);
void FireContextDestroyed(v8::Local<v8::Context> context);
void FreeContext(v8::Local<v8::Context> context);
void SetResourceNamePrefix(v8::Local<v8::String> prefix);
bool AssociateExceptionData(v8::Local<v8::Value> exception,
v8::Local<v8::Name> key,
v8::Local<v8::Value> value);
void WaitForDebugger(int context_group_id);
private:
static v8::MaybeLocal<v8::Module> ModuleResolveCallback(
v8::Local<v8::Context> context, v8::Local<v8::String> specifier,
v8::Local<v8::FixedArray> import_assertions,
v8::Local<v8::Module> referrer);
static void MessageHandler(v8::Local<v8::Message> message,
v8::Local<v8::Value> exception);
static void PromiseRejectHandler(v8::PromiseRejectMessage data);
static int HandleMessage(v8::Local<v8::Message> message,
v8::Local<v8::Value> exception);
std::vector<int> GetSessionIds(int context_group_id);
// V8InspectorClient implementation.
v8::Local<v8::Context> ensureDefaultContextInGroup(
int context_group_id) override;
double currentTimeMS() override;
v8::MaybeLocal<v8::Value> memoryInfo(v8::Isolate* isolate,
v8::Local<v8::Context>) override;
void runMessageLoopOnPause(int context_group_id) override;
void runIfWaitingForDebugger(int context_group_id) override;
void quitMessageLoopOnPause() override;
void installAdditionalCommandLineAPI(v8::Local<v8::Context>,
v8::Local<v8::Object>) override;
void consoleAPIMessage(int contextGroupId,
v8::Isolate::MessageErrorLevel level,
const v8_inspector::StringView& message,
const v8_inspector::StringView& url,
unsigned lineNumber, unsigned columnNumber,
v8_inspector::V8StackTrace*) override;
bool isInspectableHeapObject(v8::Local<v8::Object>) override;
void maxAsyncCallStackDepthChanged(int depth) override;
std::unique_ptr<v8_inspector::StringBuffer> resourceNameToUrl(
const v8_inspector::StringView& resourceName) override;
int64_t generateUniqueId() override;
// The isolate gets deleted by its {Dispose} method, not by the default
// deleter. Therefore we have to define a custom deleter for the unique_ptr to
// call {Dispose}. We have to use the unique_ptr so that the isolate get
// disposed in the right order, relative to other member variables.
struct IsolateDeleter {
void operator()(v8::Isolate* isolate) const {
// Exit the isolate after it was entered by ~InspectorIsolateData.
isolate->Exit();
isolate->Dispose();
}
};
TaskRunner* task_runner_;
SetupGlobalTasks setup_global_tasks_;
std::unique_ptr<v8::ArrayBuffer::Allocator> array_buffer_allocator_;
std::unique_ptr<v8::Isolate, IsolateDeleter> isolate_;
// The locker_ field has to come after isolate_ because the locker has to
// outlive the isolate.
base::Optional<v8::Locker> locker_;
std::unique_ptr<v8_inspector::V8Inspector> inspector_;
int last_context_group_id_ = 0;
std::map<int, std::vector<v8::Global<v8::Context>>> contexts_;
std::map<std::vector<uint16_t>, v8::Global<v8::Module>> modules_;
int last_session_id_ = 0;
std::map<int, std::unique_ptr<v8_inspector::V8InspectorSession>> sessions_;
std::map<v8_inspector::V8InspectorSession*, int> context_group_by_session_;
v8::Global<v8::Value> memory_info_;
bool current_time_set_ = false;
double current_time_ = 0.0;
bool log_console_api_message_calls_ = false;
bool log_max_async_call_stack_depth_changed_ = false;
bool waiting_for_debugger_ = false;
v8::Global<v8::Private> not_inspectable_private_;
v8::Global<v8::String> resource_name_prefix_;
v8::Global<v8::String> additional_console_api_;
};
} // namespace internal
} // namespace v8
#endif // V8_TEST_INSPECTOR_PROTOCOL_ISOLATE_DATA_H_
|
