libv8 8.4.255.0-universal-darwin-20

Sign up to get free protection for your applications and to get access to all the features.
Files changed (53) hide show
  1. checksums.yaml +7 -0
  2. data/ext/libv8/.location.yml +1 -0
  3. data/ext/libv8/location.rb +89 -0
  4. data/ext/libv8/paths.rb +28 -0
  5. data/lib/libv8.rb +9 -0
  6. data/lib/libv8/version.rb +3 -0
  7. data/vendor/v8/include/cppgc/allocation.h +124 -0
  8. data/vendor/v8/include/cppgc/garbage-collected.h +192 -0
  9. data/vendor/v8/include/cppgc/heap.h +50 -0
  10. data/vendor/v8/include/cppgc/internal/accessors.h +26 -0
  11. data/vendor/v8/include/cppgc/internal/api-constants.h +44 -0
  12. data/vendor/v8/include/cppgc/internal/compiler-specific.h +26 -0
  13. data/vendor/v8/include/cppgc/internal/finalizer-trait.h +90 -0
  14. data/vendor/v8/include/cppgc/internal/gc-info.h +43 -0
  15. data/vendor/v8/include/cppgc/internal/logging.h +50 -0
  16. data/vendor/v8/include/cppgc/internal/persistent-node.h +109 -0
  17. data/vendor/v8/include/cppgc/internal/pointer-policies.h +133 -0
  18. data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h +31 -0
  19. data/vendor/v8/include/cppgc/liveness-broker.h +50 -0
  20. data/vendor/v8/include/cppgc/macros.h +26 -0
  21. data/vendor/v8/include/cppgc/member.h +206 -0
  22. data/vendor/v8/include/cppgc/persistent.h +304 -0
  23. data/vendor/v8/include/cppgc/platform.h +31 -0
  24. data/vendor/v8/include/cppgc/prefinalizer.h +54 -0
  25. data/vendor/v8/include/cppgc/source-location.h +59 -0
  26. data/vendor/v8/include/cppgc/trace-trait.h +67 -0
  27. data/vendor/v8/include/cppgc/type-traits.h +109 -0
  28. data/vendor/v8/include/cppgc/visitor.h +137 -0
  29. data/vendor/v8/include/libplatform/libplatform-export.h +29 -0
  30. data/vendor/v8/include/libplatform/libplatform.h +85 -0
  31. data/vendor/v8/include/libplatform/v8-tracing.h +332 -0
  32. data/vendor/v8/include/v8-fast-api-calls.h +412 -0
  33. data/vendor/v8/include/v8-inspector-protocol.h +13 -0
  34. data/vendor/v8/include/v8-inspector.h +327 -0
  35. data/vendor/v8/include/v8-internal.h +389 -0
  36. data/vendor/v8/include/v8-platform.h +577 -0
  37. data/vendor/v8/include/v8-profiler.h +1059 -0
  38. data/vendor/v8/include/v8-util.h +652 -0
  39. data/vendor/v8/include/v8-value-serializer-version.h +24 -0
  40. data/vendor/v8/include/v8-version-string.h +38 -0
  41. data/vendor/v8/include/v8-version.h +20 -0
  42. data/vendor/v8/include/v8-wasm-trap-handler-posix.h +31 -0
  43. data/vendor/v8/include/v8-wasm-trap-handler-win.h +28 -0
  44. data/vendor/v8/include/v8.h +12018 -0
  45. data/vendor/v8/include/v8config.h +465 -0
  46. data/vendor/v8/out.gn/libv8/obj/libv8_libbase.a +0 -0
  47. data/vendor/v8/out.gn/libv8/obj/libv8_libplatform.a +0 -0
  48. data/vendor/v8/out.gn/libv8/obj/libv8_monolith.a +0 -0
  49. data/vendor/v8/out.gn/libv8/obj/third_party/icu/libicui18n.a +0 -0
  50. data/vendor/v8/out.gn/libv8/obj/third_party/icu/libicuuc.a +0 -0
  51. data/vendor/v8/out.gn/libv8/obj/third_party/zlib/google/libcompression_utils_portable.a +0 -0
  52. data/vendor/v8/out.gn/libv8/obj/third_party/zlib/libchrome_zlib.a +0 -0
  53. metadata +138 -0
@@ -0,0 +1,412 @@
1
+ // Copyright 2020 the V8 project authors. All rights reserved.
2
+ // Use of this source code is governed by a BSD-style license that can be
3
+ // found in the LICENSE file.
4
+
5
+ /**
6
+ * This file provides additional API on top of the default one for making
7
+ * API calls, which come from embedder C++ functions. The functions are being
8
+ * called directly from optimized code, doing all the necessary typechecks
9
+ * in the compiler itself, instead of on the embedder side. Hence the "fast"
10
+ * in the name. Example usage might look like:
11
+ *
12
+ * \code
13
+ * void FastMethod(int param, bool another_param);
14
+ *
15
+ * v8::FunctionTemplate::New(isolate, SlowCallback, data,
16
+ * signature, length, constructor_behavior
17
+ * side_effect_type,
18
+ * &v8::CFunction::Make(FastMethod));
19
+ * \endcode
20
+ *
21
+ * An example for custom embedder type support might employ a way to wrap/
22
+ * unwrap various C++ types in JSObject instances, e.g:
23
+ *
24
+ * \code
25
+ *
26
+ * // Represents the way this type system maps C++ and JS values.
27
+ * struct WrapperTypeInfo {
28
+ * // Store e.g. a method to map from exposed C++ types to the already
29
+ * // created v8::FunctionTemplate's for instantiating them.
30
+ * };
31
+ *
32
+ * // Helper method with a sanity check.
33
+ * template <typename T, int offset>
34
+ * inline T* GetInternalField(v8::Local<v8::Object> wrapper) {
35
+ * assert(offset < wrapper->InternalFieldCount());
36
+ * return reinterpret_cast<T*>(
37
+ * wrapper->GetAlignedPointerFromInternalField(offset));
38
+ * }
39
+ *
40
+ * // Returns the type info from a wrapper JS object.
41
+ * inline const WrapperTypeInfo* ToWrapperTypeInfo(
42
+ * v8::Local<v8::Object> wrapper) {
43
+ * return GetInternalField<WrapperTypeInfo,
44
+ * kV8EmbedderWrapperTypeIndex>(wrapper);
45
+ * }
46
+ *
47
+ * class CustomEmbedderType {
48
+ * public:
49
+ * static constexpr const WrapperTypeInfo* GetWrapperTypeInfo() {
50
+ * return &custom_type_wrapper_type_info;
51
+ * }
52
+ * // Returns the raw C object from a wrapper JS object.
53
+ * static CustomEmbedderType* Unwrap(v8::Local<v8::Object> wrapper) {
54
+ * return GetInternalField<CustomEmbedderType,
55
+ * kV8EmbedderWrapperObjectIndex>(wrapper);
56
+ * }
57
+ * static void FastMethod(CustomEmbedderType* receiver, int param) {
58
+ * assert(receiver != nullptr);
59
+ * // Type checks are already done by the optimized code.
60
+ * // Then call some performance-critical method like:
61
+ * // receiver->Method(param);
62
+ * }
63
+ *
64
+ * static void SlowMethod(
65
+ * const v8::FunctionCallbackInfo<v8::Value>& info) {
66
+ * v8::Local<v8::Object> instance =
67
+ * v8::Local<v8::Object>::Cast(info.Holder());
68
+ * CustomEmbedderType* receiver = Unwrap(instance);
69
+ * // TODO: Do type checks and extract {param}.
70
+ * FastMethod(receiver, param);
71
+ * }
72
+ *
73
+ * private:
74
+ * static const WrapperTypeInfo custom_type_wrapper_type_info;
75
+ * };
76
+ *
77
+ * // Support for custom embedder types via specialization of WrapperTraits.
78
+ * namespace v8 {
79
+ * template <>
80
+ * class WrapperTraits<CustomEmbedderType> {
81
+ * public:
82
+ * static const void* GetTypeInfo() {
83
+ * // We use the already defined machinery for the custom type.
84
+ * return CustomEmbedderType::GetWrapperTypeInfo();
85
+ * }
86
+ * };
87
+ * } // namespace v8
88
+ *
89
+ * // The constants kV8EmbedderWrapperTypeIndex and
90
+ * // kV8EmbedderWrapperObjectIndex describe the offsets for the type info
91
+ * // struct (the one returned by WrapperTraits::GetTypeInfo) and the
92
+ * // native object, when expressed as internal field indices within a
93
+ * // JSObject. The existance of this helper function assumes that all
94
+ * // embedder objects have their JSObject-side type info at the same
95
+ * // offset, but this is not a limitation of the API itself. For a detailed
96
+ * // use case, see the third example.
97
+ * static constexpr int kV8EmbedderWrapperTypeIndex = 0;
98
+ * static constexpr int kV8EmbedderWrapperObjectIndex = 1;
99
+ *
100
+ * // The following setup function can be templatized based on
101
+ * // the {embedder_object} argument.
102
+ * void SetupCustomEmbedderObject(v8::Isolate* isolate,
103
+ * v8::Local<v8::Context> context,
104
+ * CustomEmbedderType* embedder_object) {
105
+ * isolate->set_embedder_wrapper_type_index(
106
+ * kV8EmbedderWrapperTypeIndex);
107
+ * isolate->set_embedder_wrapper_object_index(
108
+ * kV8EmbedderWrapperObjectIndex);
109
+ *
110
+ * v8::CFunction c_func =
111
+ * MakeV8CFunction(CustomEmbedderType::FastMethod);
112
+ *
113
+ * Local<v8::FunctionTemplate> method_template =
114
+ * v8::FunctionTemplate::New(
115
+ * isolate, CustomEmbedderType::SlowMethod, v8::Local<v8::Value>(),
116
+ * v8::Local<v8::Signature>(), 1, v8::ConstructorBehavior::kAllow,
117
+ * v8::SideEffectType::kHasSideEffect, &c_func);
118
+ *
119
+ * v8::Local<v8::ObjectTemplate> object_template =
120
+ * v8::ObjectTemplate::New(isolate);
121
+ * object_template->SetInternalFieldCount(
122
+ * kV8EmbedderWrapperObjectIndex + 1);
123
+ * object_template->Set(
124
+ v8::String::NewFromUtf8Literal(isolate, "method"), method_template);
125
+ *
126
+ * // Instantiate the wrapper JS object.
127
+ * v8::Local<v8::Object> object =
128
+ * object_template->NewInstance(context).ToLocalChecked();
129
+ * object->SetAlignedPointerInInternalField(
130
+ * kV8EmbedderWrapperObjectIndex,
131
+ * reinterpret_cast<void*>(embedder_object));
132
+ *
133
+ * // TODO: Expose {object} where it's necessary.
134
+ * }
135
+ * \endcode
136
+ *
137
+ * For instance if {object} is exposed via a global "obj" variable,
138
+ * one could write in JS:
139
+ * function hot_func() {
140
+ * obj.method(42);
141
+ * }
142
+ * and once {hot_func} gets optimized, CustomEmbedderType::FastMethod
143
+ * will be called instead of the slow version, with the following arguments:
144
+ * receiver := the {embedder_object} from above
145
+ * param := 42
146
+ *
147
+ * Currently only void return types are supported.
148
+ * Currently supported argument types:
149
+ * - pointer to an embedder type
150
+ * - bool
151
+ * - int32_t
152
+ * - uint32_t
153
+ * To be supported types:
154
+ * - int64_t
155
+ * - uint64_t
156
+ * - float32_t
157
+ * - float64_t
158
+ * - arrays of C types
159
+ * - arrays of embedder types
160
+ */
161
+
162
+ #ifndef INCLUDE_V8_FAST_API_CALLS_H_
163
+ #define INCLUDE_V8_FAST_API_CALLS_H_
164
+
165
+ #include <stddef.h>
166
+ #include <stdint.h>
167
+
168
+ #include "v8config.h" // NOLINT(build/include_directory)
169
+
170
+ namespace v8 {
171
+
172
+ class CTypeInfo {
173
+ public:
174
+ enum class Type : char {
175
+ kVoid,
176
+ kBool,
177
+ kInt32,
178
+ kUint32,
179
+ kInt64,
180
+ kUint64,
181
+ kFloat32,
182
+ kFloat64,
183
+ kUnwrappedApiObject,
184
+ };
185
+
186
+ enum class ArgFlags : uint8_t {
187
+ kNone = 0,
188
+ kIsArrayBit = 1 << 0, // This argument is first in an array of values.
189
+ };
190
+
191
+ static CTypeInfo FromWrapperType(const void* wrapper_type_info,
192
+ ArgFlags flags = ArgFlags::kNone) {
193
+ uintptr_t wrapper_type_info_ptr =
194
+ reinterpret_cast<uintptr_t>(wrapper_type_info);
195
+ // Check that the lower kIsWrapperTypeBit bits are 0's.
196
+ CHECK_EQ(
197
+ wrapper_type_info_ptr & ~(static_cast<uintptr_t>(~0)
198
+ << static_cast<uintptr_t>(kIsWrapperTypeBit)),
199
+ 0u);
200
+ // TODO(mslekova): Refactor the manual bit manipulations to use
201
+ // PointerWithPayload instead.
202
+ return CTypeInfo(wrapper_type_info_ptr | static_cast<int>(flags) |
203
+ kIsWrapperTypeBit);
204
+ }
205
+
206
+ static constexpr CTypeInfo FromCType(Type ctype,
207
+ ArgFlags flags = ArgFlags::kNone) {
208
+ // ctype cannot be Type::kUnwrappedApiObject.
209
+ return CTypeInfo(
210
+ ((static_cast<uintptr_t>(ctype) << kTypeOffset) & kTypeMask) |
211
+ static_cast<int>(flags));
212
+ }
213
+
214
+ const void* GetWrapperInfo() const;
215
+
216
+ constexpr Type GetType() const {
217
+ if (payload_ & kIsWrapperTypeBit) {
218
+ return Type::kUnwrappedApiObject;
219
+ }
220
+ return static_cast<Type>((payload_ & kTypeMask) >> kTypeOffset);
221
+ }
222
+
223
+ constexpr bool IsArray() const {
224
+ return payload_ & static_cast<int>(ArgFlags::kIsArrayBit);
225
+ }
226
+
227
+ private:
228
+ explicit constexpr CTypeInfo(uintptr_t payload) : payload_(payload) {}
229
+
230
+ // That must be the last bit after ArgFlags.
231
+ static constexpr uintptr_t kIsWrapperTypeBit = 1 << 1;
232
+ static constexpr uintptr_t kWrapperTypeInfoMask = static_cast<uintptr_t>(~0)
233
+ << 2;
234
+
235
+ static constexpr unsigned int kTypeOffset = kIsWrapperTypeBit;
236
+ static constexpr unsigned int kTypeSize = 8 - kTypeOffset;
237
+ static constexpr uintptr_t kTypeMask =
238
+ (~(static_cast<uintptr_t>(~0) << kTypeSize)) << kTypeOffset;
239
+
240
+ const uintptr_t payload_;
241
+ };
242
+
243
+ class CFunctionInfo {
244
+ public:
245
+ virtual const CTypeInfo& ReturnInfo() const = 0;
246
+ virtual unsigned int ArgumentCount() const = 0;
247
+ virtual const CTypeInfo& ArgumentInfo(unsigned int index) const = 0;
248
+ };
249
+
250
+ template <typename T>
251
+ class WrapperTraits {
252
+ public:
253
+ static const void* GetTypeInfo() {
254
+ static_assert(sizeof(T) != sizeof(T),
255
+ "WrapperTraits must be specialized for this type.");
256
+ return nullptr;
257
+ }
258
+ };
259
+
260
+ namespace internal {
261
+
262
+ template <typename T>
263
+ struct GetCType {
264
+ static_assert(sizeof(T) != sizeof(T), "Unsupported CType");
265
+ };
266
+
267
+ #define SPECIALIZE_GET_C_TYPE_FOR(ctype, ctypeinfo) \
268
+ template <> \
269
+ struct GetCType<ctype> { \
270
+ static constexpr CTypeInfo Get() { \
271
+ return CTypeInfo::FromCType(CTypeInfo::Type::ctypeinfo); \
272
+ } \
273
+ };
274
+
275
+ #define SUPPORTED_C_TYPES(V) \
276
+ V(void, kVoid) \
277
+ V(bool, kBool) \
278
+ V(int32_t, kInt32) \
279
+ V(uint32_t, kUint32) \
280
+ V(int64_t, kInt64) \
281
+ V(uint64_t, kUint64) \
282
+ V(float, kFloat32) \
283
+ V(double, kFloat64)
284
+
285
+ SUPPORTED_C_TYPES(SPECIALIZE_GET_C_TYPE_FOR)
286
+
287
+ template <typename T, typename = void>
288
+ struct EnableIfHasWrapperTypeInfo {};
289
+
290
+ template <typename T>
291
+ struct EnableIfHasWrapperTypeInfo<T, decltype(WrapperTraits<T>::GetTypeInfo(),
292
+ void())> {
293
+ typedef void type;
294
+ };
295
+
296
+ // T* where T is a primitive (array of primitives).
297
+ template <typename T, typename = void>
298
+ struct GetCTypePointerImpl {
299
+ static constexpr CTypeInfo Get() {
300
+ return CTypeInfo::FromCType(GetCType<T>::Get().GetType(),
301
+ CTypeInfo::ArgFlags::kIsArrayBit);
302
+ }
303
+ };
304
+
305
+ // T* where T is an API object.
306
+ template <typename T>
307
+ struct GetCTypePointerImpl<T, typename EnableIfHasWrapperTypeInfo<T>::type> {
308
+ static constexpr CTypeInfo Get() {
309
+ return CTypeInfo::FromWrapperType(WrapperTraits<T>::GetTypeInfo());
310
+ }
311
+ };
312
+
313
+ // T** where T is a primitive. Not allowed.
314
+ template <typename T, typename = void>
315
+ struct GetCTypePointerPointerImpl {
316
+ static_assert(sizeof(T**) != sizeof(T**), "Unsupported type");
317
+ };
318
+
319
+ // T** where T is an API object (array of API objects).
320
+ template <typename T>
321
+ struct GetCTypePointerPointerImpl<
322
+ T, typename EnableIfHasWrapperTypeInfo<T>::type> {
323
+ static constexpr CTypeInfo Get() {
324
+ return CTypeInfo::FromWrapperType(WrapperTraits<T>::GetTypeInfo(),
325
+ CTypeInfo::ArgFlags::kIsArrayBit);
326
+ }
327
+ };
328
+
329
+ template <typename T>
330
+ struct GetCType<T**> : public GetCTypePointerPointerImpl<T> {};
331
+
332
+ template <typename T>
333
+ struct GetCType<T*> : public GetCTypePointerImpl<T> {};
334
+
335
+ template <typename R, typename... Args>
336
+ class CFunctionInfoImpl : public CFunctionInfo {
337
+ public:
338
+ CFunctionInfoImpl()
339
+ : return_info_(internal::GetCType<R>::Get()),
340
+ arg_count_(sizeof...(Args)),
341
+ arg_info_{internal::GetCType<Args>::Get()...} {
342
+ static_assert(
343
+ internal::GetCType<R>::Get().GetType() == CTypeInfo::Type::kVoid,
344
+ "Only void return types are currently supported.");
345
+ }
346
+
347
+ const CTypeInfo& ReturnInfo() const override { return return_info_; }
348
+ unsigned int ArgumentCount() const override { return arg_count_; }
349
+ const CTypeInfo& ArgumentInfo(unsigned int index) const override {
350
+ CHECK_LT(index, ArgumentCount());
351
+ return arg_info_[index];
352
+ }
353
+
354
+ private:
355
+ CTypeInfo return_info_;
356
+ const unsigned int arg_count_;
357
+ CTypeInfo arg_info_[sizeof...(Args)];
358
+ };
359
+
360
+ } // namespace internal
361
+
362
+ class V8_EXPORT CFunction {
363
+ public:
364
+ constexpr CFunction() : address_(nullptr), type_info_(nullptr) {}
365
+
366
+ const CTypeInfo& ReturnInfo() const { return type_info_->ReturnInfo(); }
367
+
368
+ const CTypeInfo& ArgumentInfo(unsigned int index) const {
369
+ return type_info_->ArgumentInfo(index);
370
+ }
371
+
372
+ unsigned int ArgumentCount() const { return type_info_->ArgumentCount(); }
373
+
374
+ const void* GetAddress() const { return address_; }
375
+ const CFunctionInfo* GetTypeInfo() const { return type_info_; }
376
+
377
+ template <typename F>
378
+ static CFunction Make(F* func) {
379
+ return ArgUnwrap<F*>::Make(func);
380
+ }
381
+
382
+ private:
383
+ const void* address_;
384
+ const CFunctionInfo* type_info_;
385
+
386
+ CFunction(const void* address, const CFunctionInfo* type_info);
387
+
388
+ template <typename R, typename... Args>
389
+ static CFunctionInfo* GetCFunctionInfo() {
390
+ static internal::CFunctionInfoImpl<R, Args...> instance;
391
+ return &instance;
392
+ }
393
+
394
+ template <typename F>
395
+ class ArgUnwrap {
396
+ static_assert(sizeof(F) != sizeof(F),
397
+ "CFunction must be created from a function pointer.");
398
+ };
399
+
400
+ template <typename R, typename... Args>
401
+ class ArgUnwrap<R (*)(Args...)> {
402
+ public:
403
+ static CFunction Make(R (*func)(Args...)) {
404
+ return CFunction(reinterpret_cast<const void*>(func),
405
+ GetCFunctionInfo<R, Args...>());
406
+ }
407
+ };
408
+ };
409
+
410
+ } // namespace v8
411
+
412
+ #endif // INCLUDE_V8_FAST_API_CALLS_H_
@@ -0,0 +1,13 @@
1
+ // Copyright 2016 the V8 project authors. All rights reserved.
2
+ // Use of this source code is governed by a BSD-style license that can be
3
+ // found in the LICENSE file.
4
+
5
+ #ifndef V8_V8_INSPECTOR_PROTOCOL_H_
6
+ #define V8_V8_INSPECTOR_PROTOCOL_H_
7
+
8
+ #include "inspector/Debugger.h" // NOLINT(build/include_directory)
9
+ #include "inspector/Runtime.h" // NOLINT(build/include_directory)
10
+ #include "inspector/Schema.h" // NOLINT(build/include_directory)
11
+ #include "v8-inspector.h" // NOLINT(build/include_directory)
12
+
13
+ #endif // V8_V8_INSPECTOR_PROTOCOL_H_
@@ -0,0 +1,327 @@
1
+ // Copyright 2016 the V8 project authors. All rights reserved.
2
+ // Use of this source code is governed by a BSD-style license that can be
3
+ // found in the LICENSE file.
4
+
5
+ #ifndef V8_V8_INSPECTOR_H_
6
+ #define V8_V8_INSPECTOR_H_
7
+
8
+ #include <stdint.h>
9
+ #include <cctype>
10
+
11
+ #include <memory>
12
+ #include <unordered_map>
13
+
14
+ #include "v8.h" // NOLINT(build/include_directory)
15
+
16
+ namespace v8_inspector {
17
+
18
+ namespace protocol {
19
+ namespace Debugger {
20
+ namespace API {
21
+ class SearchMatch;
22
+ }
23
+ }
24
+ namespace Runtime {
25
+ namespace API {
26
+ class RemoteObject;
27
+ class StackTrace;
28
+ class StackTraceId;
29
+ }
30
+ }
31
+ namespace Schema {
32
+ namespace API {
33
+ class Domain;
34
+ }
35
+ }
36
+ } // namespace protocol
37
+
38
+ class V8_EXPORT StringView {
39
+ public:
40
+ StringView() : m_is8Bit(true), m_length(0), m_characters8(nullptr) {}
41
+
42
+ StringView(const uint8_t* characters, size_t length)
43
+ : m_is8Bit(true), m_length(length), m_characters8(characters) {}
44
+
45
+ StringView(const uint16_t* characters, size_t length)
46
+ : m_is8Bit(false), m_length(length), m_characters16(characters) {}
47
+
48
+ bool is8Bit() const { return m_is8Bit; }
49
+ size_t length() const { return m_length; }
50
+
51
+ // TODO(dgozman): add DCHECK(m_is8Bit) to accessors once platform can be used
52
+ // here.
53
+ const uint8_t* characters8() const { return m_characters8; }
54
+ const uint16_t* characters16() const { return m_characters16; }
55
+
56
+ private:
57
+ bool m_is8Bit;
58
+ size_t m_length;
59
+ union {
60
+ const uint8_t* m_characters8;
61
+ const uint16_t* m_characters16;
62
+ };
63
+ };
64
+
65
+ class V8_EXPORT StringBuffer {
66
+ public:
67
+ virtual ~StringBuffer() = default;
68
+ virtual StringView string() const = 0;
69
+ // This method copies contents.
70
+ static std::unique_ptr<StringBuffer> create(StringView);
71
+ };
72
+
73
+ class V8_EXPORT V8ContextInfo {
74
+ public:
75
+ V8ContextInfo(v8::Local<v8::Context> context, int contextGroupId,
76
+ StringView humanReadableName)
77
+ : context(context),
78
+ contextGroupId(contextGroupId),
79
+ humanReadableName(humanReadableName),
80
+ hasMemoryOnConsole(false) {}
81
+
82
+ v8::Local<v8::Context> context;
83
+ // Each v8::Context is a part of a group. The group id must be non-zero.
84
+ int contextGroupId;
85
+ StringView humanReadableName;
86
+ StringView origin;
87
+ StringView auxData;
88
+ bool hasMemoryOnConsole;
89
+
90
+ static int executionContextId(v8::Local<v8::Context> context);
91
+
92
+ // Disallow copying and allocating this one.
93
+ enum NotNullTagEnum { NotNullLiteral };
94
+ void* operator new(size_t) = delete;
95
+ void* operator new(size_t, NotNullTagEnum, void*) = delete;
96
+ void* operator new(size_t, void*) = delete;
97
+ V8ContextInfo(const V8ContextInfo&) = delete;
98
+ V8ContextInfo& operator=(const V8ContextInfo&) = delete;
99
+ };
100
+
101
+ class V8_EXPORT V8StackTrace {
102
+ public:
103
+ virtual StringView firstNonEmptySourceURL() const = 0;
104
+ virtual bool isEmpty() const = 0;
105
+ virtual StringView topSourceURL() const = 0;
106
+ virtual int topLineNumber() const = 0;
107
+ virtual int topColumnNumber() const = 0;
108
+ virtual StringView topScriptId() const = 0;
109
+ virtual StringView topFunctionName() const = 0;
110
+
111
+ virtual ~V8StackTrace() = default;
112
+ virtual std::unique_ptr<protocol::Runtime::API::StackTrace>
113
+ buildInspectorObject() const = 0;
114
+ virtual std::unique_ptr<protocol::Runtime::API::StackTrace>
115
+ buildInspectorObject(int maxAsyncDepth) const = 0;
116
+ virtual std::unique_ptr<StringBuffer> toString() const = 0;
117
+
118
+ // Safe to pass between threads, drops async chain.
119
+ virtual std::unique_ptr<V8StackTrace> clone() = 0;
120
+ };
121
+
122
+ class V8_EXPORT V8InspectorSession {
123
+ public:
124
+ virtual ~V8InspectorSession() = default;
125
+
126
+ // Cross-context inspectable values (DOM nodes in different worlds, etc.).
127
+ class V8_EXPORT Inspectable {
128
+ public:
129
+ virtual v8::Local<v8::Value> get(v8::Local<v8::Context>) = 0;
130
+ virtual ~Inspectable() = default;
131
+ };
132
+ virtual void addInspectedObject(std::unique_ptr<Inspectable>) = 0;
133
+
134
+ // Dispatching protocol messages.
135
+ static bool canDispatchMethod(StringView method);
136
+ virtual void dispatchProtocolMessage(StringView message) = 0;
137
+ virtual std::vector<uint8_t> state() = 0;
138
+ virtual std::vector<std::unique_ptr<protocol::Schema::API::Domain>>
139
+ supportedDomains() = 0;
140
+
141
+ // Debugger actions.
142
+ virtual void schedulePauseOnNextStatement(StringView breakReason,
143
+ StringView breakDetails) = 0;
144
+ virtual void cancelPauseOnNextStatement() = 0;
145
+ virtual void breakProgram(StringView breakReason,
146
+ StringView breakDetails) = 0;
147
+ virtual void setSkipAllPauses(bool) = 0;
148
+ virtual void resume(bool setTerminateOnResume = false) = 0;
149
+ virtual void stepOver() = 0;
150
+ virtual std::vector<std::unique_ptr<protocol::Debugger::API::SearchMatch>>
151
+ searchInTextByLines(StringView text, StringView query, bool caseSensitive,
152
+ bool isRegex) = 0;
153
+
154
+ // Remote objects.
155
+ virtual std::unique_ptr<protocol::Runtime::API::RemoteObject> wrapObject(
156
+ v8::Local<v8::Context>, v8::Local<v8::Value>, StringView groupName,
157
+ bool generatePreview) = 0;
158
+
159
+ virtual bool unwrapObject(std::unique_ptr<StringBuffer>* error,
160
+ StringView objectId, v8::Local<v8::Value>*,
161
+ v8::Local<v8::Context>*,
162
+ std::unique_ptr<StringBuffer>* objectGroup) = 0;
163
+ virtual void releaseObjectGroup(StringView) = 0;
164
+ virtual void triggerPreciseCoverageDeltaUpdate(StringView occassion) = 0;
165
+ };
166
+
167
+ class V8_EXPORT V8InspectorClient {
168
+ public:
169
+ virtual ~V8InspectorClient() = default;
170
+
171
+ virtual void runMessageLoopOnPause(int contextGroupId) {}
172
+ virtual void quitMessageLoopOnPause() {}
173
+ virtual void runIfWaitingForDebugger(int contextGroupId) {}
174
+
175
+ virtual void muteMetrics(int contextGroupId) {}
176
+ virtual void unmuteMetrics(int contextGroupId) {}
177
+
178
+ virtual void beginUserGesture() {}
179
+ virtual void endUserGesture() {}
180
+
181
+ virtual std::unique_ptr<StringBuffer> valueSubtype(v8::Local<v8::Value>) {
182
+ return nullptr;
183
+ }
184
+ virtual bool formatAccessorsAsProperties(v8::Local<v8::Value>) {
185
+ return false;
186
+ }
187
+ virtual bool isInspectableHeapObject(v8::Local<v8::Object>) { return true; }
188
+
189
+ virtual v8::Local<v8::Context> ensureDefaultContextInGroup(
190
+ int contextGroupId) {
191
+ return v8::Local<v8::Context>();
192
+ }
193
+ virtual void beginEnsureAllContextsInGroup(int contextGroupId) {}
194
+ virtual void endEnsureAllContextsInGroup(int contextGroupId) {}
195
+
196
+ virtual void installAdditionalCommandLineAPI(v8::Local<v8::Context>,
197
+ v8::Local<v8::Object>) {}
198
+ virtual void consoleAPIMessage(int contextGroupId,
199
+ v8::Isolate::MessageErrorLevel level,
200
+ const StringView& message,
201
+ const StringView& url, unsigned lineNumber,
202
+ unsigned columnNumber, V8StackTrace*) {}
203
+ virtual v8::MaybeLocal<v8::Value> memoryInfo(v8::Isolate*,
204
+ v8::Local<v8::Context>) {
205
+ return v8::MaybeLocal<v8::Value>();
206
+ }
207
+
208
+ virtual void consoleTime(const StringView& title) {}
209
+ virtual void consoleTimeEnd(const StringView& title) {}
210
+ virtual void consoleTimeStamp(const StringView& title) {}
211
+ virtual void consoleClear(int contextGroupId) {}
212
+ virtual double currentTimeMS() { return 0; }
213
+ typedef void (*TimerCallback)(void*);
214
+ virtual void startRepeatingTimer(double, TimerCallback, void* data) {}
215
+ virtual void cancelTimer(void* data) {}
216
+
217
+ // TODO(dgozman): this was added to support service worker shadow page. We
218
+ // should not connect at all.
219
+ virtual bool canExecuteScripts(int contextGroupId) { return true; }
220
+
221
+ virtual void maxAsyncCallStackDepthChanged(int depth) {}
222
+
223
+ virtual std::unique_ptr<StringBuffer> resourceNameToUrl(
224
+ const StringView& resourceName) {
225
+ return nullptr;
226
+ }
227
+ };
228
+
229
+ // These stack trace ids are intended to be passed between debuggers and be
230
+ // resolved later. This allows to track cross-debugger calls and step between
231
+ // them if a single client connects to multiple debuggers.
232
+ struct V8_EXPORT V8StackTraceId {
233
+ uintptr_t id;
234
+ std::pair<int64_t, int64_t> debugger_id;
235
+ bool should_pause = false;
236
+
237
+ V8StackTraceId();
238
+ V8StackTraceId(const V8StackTraceId&) = default;
239
+ V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id);
240
+ V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id,
241
+ bool should_pause);
242
+ explicit V8StackTraceId(StringView);
243
+ V8StackTraceId& operator=(const V8StackTraceId&) = default;
244
+ V8StackTraceId& operator=(V8StackTraceId&&) noexcept = default;
245
+ ~V8StackTraceId() = default;
246
+
247
+ bool IsInvalid() const;
248
+ std::unique_ptr<StringBuffer> ToString();
249
+ };
250
+
251
+ class V8_EXPORT V8Inspector {
252
+ public:
253
+ static std::unique_ptr<V8Inspector> create(v8::Isolate*, V8InspectorClient*);
254
+ virtual ~V8Inspector() = default;
255
+
256
+ // Contexts instrumentation.
257
+ virtual void contextCreated(const V8ContextInfo&) = 0;
258
+ virtual void contextDestroyed(v8::Local<v8::Context>) = 0;
259
+ virtual void resetContextGroup(int contextGroupId) = 0;
260
+ virtual v8::MaybeLocal<v8::Context> contextById(int contextId) = 0;
261
+
262
+ // Various instrumentation.
263
+ virtual void idleStarted() = 0;
264
+ virtual void idleFinished() = 0;
265
+
266
+ // Async stack traces instrumentation.
267
+ virtual void asyncTaskScheduled(StringView taskName, void* task,
268
+ bool recurring) = 0;
269
+ virtual void asyncTaskCanceled(void* task) = 0;
270
+ virtual void asyncTaskStarted(void* task) = 0;
271
+ virtual void asyncTaskFinished(void* task) = 0;
272
+ virtual void allAsyncTasksCanceled() = 0;
273
+
274
+ virtual V8StackTraceId storeCurrentStackTrace(StringView description) = 0;
275
+ virtual void externalAsyncTaskStarted(const V8StackTraceId& parent) = 0;
276
+ virtual void externalAsyncTaskFinished(const V8StackTraceId& parent) = 0;
277
+
278
+ // Exceptions instrumentation.
279
+ virtual unsigned exceptionThrown(v8::Local<v8::Context>, StringView message,
280
+ v8::Local<v8::Value> exception,
281
+ StringView detailedMessage, StringView url,
282
+ unsigned lineNumber, unsigned columnNumber,
283
+ std::unique_ptr<V8StackTrace>,
284
+ int scriptId) = 0;
285
+ virtual void exceptionRevoked(v8::Local<v8::Context>, unsigned exceptionId,
286
+ StringView message) = 0;
287
+
288
+ // Connection.
289
+ class V8_EXPORT Channel {
290
+ public:
291
+ virtual ~Channel() = default;
292
+ virtual void sendResponse(int callId,
293
+ std::unique_ptr<StringBuffer> message) = 0;
294
+ virtual void sendNotification(std::unique_ptr<StringBuffer> message) = 0;
295
+ virtual void flushProtocolNotifications() = 0;
296
+ };
297
+ virtual std::unique_ptr<V8InspectorSession> connect(int contextGroupId,
298
+ Channel*,
299
+ StringView state) = 0;
300
+
301
+ // API methods.
302
+ virtual std::unique_ptr<V8StackTrace> createStackTrace(
303
+ v8::Local<v8::StackTrace>) = 0;
304
+ virtual std::unique_ptr<V8StackTrace> captureStackTrace(bool fullStack) = 0;
305
+
306
+ // Performance counters.
307
+ class V8_EXPORT Counters : public std::enable_shared_from_this<Counters> {
308
+ public:
309
+ explicit Counters(v8::Isolate* isolate);
310
+ ~Counters();
311
+ const std::unordered_map<std::string, int>& getCountersMap() const {
312
+ return m_countersMap;
313
+ }
314
+
315
+ private:
316
+ static int* getCounterPtr(const char* name);
317
+
318
+ v8::Isolate* m_isolate;
319
+ std::unordered_map<std::string, int> m_countersMap;
320
+ };
321
+
322
+ virtual std::shared_ptr<Counters> enableCounters() = 0;
323
+ };
324
+
325
+ } // namespace v8_inspector
326
+
327
+ #endif // V8_V8_INSPECTOR_H_