libv8-node 15.14.0.1-arm64-darwin-21
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +7 -0
- data/ext/libv8-node/.location.yml +1 -0
- data/ext/libv8-node/location.rb +76 -0
- data/ext/libv8-node/paths.rb +30 -0
- data/lib/libv8/node/version.rb +7 -0
- data/lib/libv8/node.rb +11 -0
- data/lib/libv8-node.rb +1 -0
- data/vendor/v8/include/cppgc/allocation.h +173 -0
- data/vendor/v8/include/cppgc/common.h +26 -0
- data/vendor/v8/include/cppgc/custom-space.h +62 -0
- data/vendor/v8/include/cppgc/default-platform.h +76 -0
- data/vendor/v8/include/cppgc/garbage-collected.h +116 -0
- data/vendor/v8/include/cppgc/heap.h +139 -0
- data/vendor/v8/include/cppgc/internal/api-constants.h +47 -0
- data/vendor/v8/include/cppgc/internal/atomic-entry-flag.h +48 -0
- data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h +67 -0
- data/vendor/v8/include/cppgc/internal/compiler-specific.h +38 -0
- data/vendor/v8/include/cppgc/internal/finalizer-trait.h +90 -0
- data/vendor/v8/include/cppgc/internal/gc-info.h +45 -0
- data/vendor/v8/include/cppgc/internal/logging.h +50 -0
- data/vendor/v8/include/cppgc/internal/persistent-node.h +116 -0
- data/vendor/v8/include/cppgc/internal/pointer-policies.h +134 -0
- data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h +30 -0
- data/vendor/v8/include/cppgc/internal/process-heap.h +34 -0
- data/vendor/v8/include/cppgc/internal/write-barrier.h +78 -0
- data/vendor/v8/include/cppgc/liveness-broker.h +68 -0
- data/vendor/v8/include/cppgc/macros.h +24 -0
- data/vendor/v8/include/cppgc/member.h +226 -0
- data/vendor/v8/include/cppgc/persistent.h +341 -0
- data/vendor/v8/include/cppgc/platform.h +130 -0
- data/vendor/v8/include/cppgc/prefinalizer.h +52 -0
- data/vendor/v8/include/cppgc/source-location.h +91 -0
- data/vendor/v8/include/cppgc/trace-trait.h +111 -0
- data/vendor/v8/include/cppgc/type-traits.h +109 -0
- data/vendor/v8/include/cppgc/visitor.h +213 -0
- data/vendor/v8/include/libplatform/libplatform-export.h +29 -0
- data/vendor/v8/include/libplatform/libplatform.h +106 -0
- data/vendor/v8/include/libplatform/v8-tracing.h +332 -0
- data/vendor/v8/include/v8-cppgc.h +226 -0
- data/vendor/v8/include/v8-fast-api-calls.h +388 -0
- data/vendor/v8/include/v8-inspector-protocol.h +13 -0
- data/vendor/v8/include/v8-inspector.h +327 -0
- data/vendor/v8/include/v8-internal.h +427 -0
- data/vendor/v8/include/v8-metrics.h +133 -0
- data/vendor/v8/include/v8-platform.h +684 -0
- data/vendor/v8/include/v8-profiler.h +1059 -0
- data/vendor/v8/include/v8-util.h +652 -0
- data/vendor/v8/include/v8-value-serializer-version.h +24 -0
- data/vendor/v8/include/v8-version-string.h +38 -0
- data/vendor/v8/include/v8-version.h +20 -0
- data/vendor/v8/include/v8-wasm-trap-handler-posix.h +31 -0
- data/vendor/v8/include/v8-wasm-trap-handler-win.h +28 -0
- data/vendor/v8/include/v8.h +12098 -0
- data/vendor/v8/include/v8config.h +484 -0
- data/vendor/v8/out.gn/libv8/obj/libv8_monolith.a +0 -0
- metadata +126 -0
@@ -0,0 +1,332 @@
|
|
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_LIBPLATFORM_V8_TRACING_H_
|
6
|
+
#define V8_LIBPLATFORM_V8_TRACING_H_
|
7
|
+
|
8
|
+
#include <atomic>
|
9
|
+
#include <fstream>
|
10
|
+
#include <memory>
|
11
|
+
#include <unordered_set>
|
12
|
+
#include <vector>
|
13
|
+
|
14
|
+
#include "libplatform/libplatform-export.h"
|
15
|
+
#include "v8-platform.h" // NOLINT(build/include_directory)
|
16
|
+
|
17
|
+
namespace perfetto {
|
18
|
+
namespace trace_processor {
|
19
|
+
class TraceProcessorStorage;
|
20
|
+
}
|
21
|
+
class TracingSession;
|
22
|
+
}
|
23
|
+
|
24
|
+
namespace v8 {
|
25
|
+
|
26
|
+
namespace base {
|
27
|
+
class Mutex;
|
28
|
+
} // namespace base
|
29
|
+
|
30
|
+
namespace platform {
|
31
|
+
namespace tracing {
|
32
|
+
|
33
|
+
class TraceEventListener;
|
34
|
+
|
35
|
+
const int kTraceMaxNumArgs = 2;
|
36
|
+
|
37
|
+
class V8_PLATFORM_EXPORT TraceObject {
|
38
|
+
public:
|
39
|
+
union ArgValue {
|
40
|
+
V8_DEPRECATED("use as_uint ? true : false") bool as_bool;
|
41
|
+
uint64_t as_uint;
|
42
|
+
int64_t as_int;
|
43
|
+
double as_double;
|
44
|
+
const void* as_pointer;
|
45
|
+
const char* as_string;
|
46
|
+
};
|
47
|
+
|
48
|
+
TraceObject() = default;
|
49
|
+
~TraceObject();
|
50
|
+
void Initialize(
|
51
|
+
char phase, const uint8_t* category_enabled_flag, const char* name,
|
52
|
+
const char* scope, uint64_t id, uint64_t bind_id, int num_args,
|
53
|
+
const char** arg_names, const uint8_t* arg_types,
|
54
|
+
const uint64_t* arg_values,
|
55
|
+
std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables,
|
56
|
+
unsigned int flags, int64_t timestamp, int64_t cpu_timestamp);
|
57
|
+
void UpdateDuration(int64_t timestamp, int64_t cpu_timestamp);
|
58
|
+
void InitializeForTesting(
|
59
|
+
char phase, const uint8_t* category_enabled_flag, const char* name,
|
60
|
+
const char* scope, uint64_t id, uint64_t bind_id, int num_args,
|
61
|
+
const char** arg_names, const uint8_t* arg_types,
|
62
|
+
const uint64_t* arg_values,
|
63
|
+
std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables,
|
64
|
+
unsigned int flags, int pid, int tid, int64_t ts, int64_t tts,
|
65
|
+
uint64_t duration, uint64_t cpu_duration);
|
66
|
+
|
67
|
+
int pid() const { return pid_; }
|
68
|
+
int tid() const { return tid_; }
|
69
|
+
char phase() const { return phase_; }
|
70
|
+
const uint8_t* category_enabled_flag() const {
|
71
|
+
return category_enabled_flag_;
|
72
|
+
}
|
73
|
+
const char* name() const { return name_; }
|
74
|
+
const char* scope() const { return scope_; }
|
75
|
+
uint64_t id() const { return id_; }
|
76
|
+
uint64_t bind_id() const { return bind_id_; }
|
77
|
+
int num_args() const { return num_args_; }
|
78
|
+
const char** arg_names() { return arg_names_; }
|
79
|
+
uint8_t* arg_types() { return arg_types_; }
|
80
|
+
ArgValue* arg_values() { return arg_values_; }
|
81
|
+
std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables() {
|
82
|
+
return arg_convertables_;
|
83
|
+
}
|
84
|
+
unsigned int flags() const { return flags_; }
|
85
|
+
int64_t ts() { return ts_; }
|
86
|
+
int64_t tts() { return tts_; }
|
87
|
+
uint64_t duration() { return duration_; }
|
88
|
+
uint64_t cpu_duration() { return cpu_duration_; }
|
89
|
+
|
90
|
+
private:
|
91
|
+
int pid_;
|
92
|
+
int tid_;
|
93
|
+
char phase_;
|
94
|
+
const char* name_;
|
95
|
+
const char* scope_;
|
96
|
+
const uint8_t* category_enabled_flag_;
|
97
|
+
uint64_t id_;
|
98
|
+
uint64_t bind_id_;
|
99
|
+
int num_args_ = 0;
|
100
|
+
const char* arg_names_[kTraceMaxNumArgs];
|
101
|
+
uint8_t arg_types_[kTraceMaxNumArgs];
|
102
|
+
ArgValue arg_values_[kTraceMaxNumArgs];
|
103
|
+
std::unique_ptr<v8::ConvertableToTraceFormat>
|
104
|
+
arg_convertables_[kTraceMaxNumArgs];
|
105
|
+
char* parameter_copy_storage_ = nullptr;
|
106
|
+
unsigned int flags_;
|
107
|
+
int64_t ts_;
|
108
|
+
int64_t tts_;
|
109
|
+
uint64_t duration_;
|
110
|
+
uint64_t cpu_duration_;
|
111
|
+
|
112
|
+
// Disallow copy and assign
|
113
|
+
TraceObject(const TraceObject&) = delete;
|
114
|
+
void operator=(const TraceObject&) = delete;
|
115
|
+
};
|
116
|
+
|
117
|
+
class V8_PLATFORM_EXPORT TraceWriter {
|
118
|
+
public:
|
119
|
+
TraceWriter() = default;
|
120
|
+
virtual ~TraceWriter() = default;
|
121
|
+
virtual void AppendTraceEvent(TraceObject* trace_event) = 0;
|
122
|
+
virtual void Flush() = 0;
|
123
|
+
|
124
|
+
static TraceWriter* CreateJSONTraceWriter(std::ostream& stream);
|
125
|
+
static TraceWriter* CreateJSONTraceWriter(std::ostream& stream,
|
126
|
+
const std::string& tag);
|
127
|
+
|
128
|
+
private:
|
129
|
+
// Disallow copy and assign
|
130
|
+
TraceWriter(const TraceWriter&) = delete;
|
131
|
+
void operator=(const TraceWriter&) = delete;
|
132
|
+
};
|
133
|
+
|
134
|
+
class V8_PLATFORM_EXPORT TraceBufferChunk {
|
135
|
+
public:
|
136
|
+
explicit TraceBufferChunk(uint32_t seq);
|
137
|
+
|
138
|
+
void Reset(uint32_t new_seq);
|
139
|
+
bool IsFull() const { return next_free_ == kChunkSize; }
|
140
|
+
TraceObject* AddTraceEvent(size_t* event_index);
|
141
|
+
TraceObject* GetEventAt(size_t index) { return &chunk_[index]; }
|
142
|
+
|
143
|
+
uint32_t seq() const { return seq_; }
|
144
|
+
size_t size() const { return next_free_; }
|
145
|
+
|
146
|
+
static const size_t kChunkSize = 64;
|
147
|
+
|
148
|
+
private:
|
149
|
+
size_t next_free_ = 0;
|
150
|
+
TraceObject chunk_[kChunkSize];
|
151
|
+
uint32_t seq_;
|
152
|
+
|
153
|
+
// Disallow copy and assign
|
154
|
+
TraceBufferChunk(const TraceBufferChunk&) = delete;
|
155
|
+
void operator=(const TraceBufferChunk&) = delete;
|
156
|
+
};
|
157
|
+
|
158
|
+
class V8_PLATFORM_EXPORT TraceBuffer {
|
159
|
+
public:
|
160
|
+
TraceBuffer() = default;
|
161
|
+
virtual ~TraceBuffer() = default;
|
162
|
+
|
163
|
+
virtual TraceObject* AddTraceEvent(uint64_t* handle) = 0;
|
164
|
+
virtual TraceObject* GetEventByHandle(uint64_t handle) = 0;
|
165
|
+
virtual bool Flush() = 0;
|
166
|
+
|
167
|
+
static const size_t kRingBufferChunks = 1024;
|
168
|
+
|
169
|
+
static TraceBuffer* CreateTraceBufferRingBuffer(size_t max_chunks,
|
170
|
+
TraceWriter* trace_writer);
|
171
|
+
|
172
|
+
private:
|
173
|
+
// Disallow copy and assign
|
174
|
+
TraceBuffer(const TraceBuffer&) = delete;
|
175
|
+
void operator=(const TraceBuffer&) = delete;
|
176
|
+
};
|
177
|
+
|
178
|
+
// Options determines how the trace buffer stores data.
|
179
|
+
enum TraceRecordMode {
|
180
|
+
// Record until the trace buffer is full.
|
181
|
+
RECORD_UNTIL_FULL,
|
182
|
+
|
183
|
+
// Record until the user ends the trace. The trace buffer is a fixed size
|
184
|
+
// and we use it as a ring buffer during recording.
|
185
|
+
RECORD_CONTINUOUSLY,
|
186
|
+
|
187
|
+
// Record until the trace buffer is full, but with a huge buffer size.
|
188
|
+
RECORD_AS_MUCH_AS_POSSIBLE,
|
189
|
+
|
190
|
+
// Echo to console. Events are discarded.
|
191
|
+
ECHO_TO_CONSOLE,
|
192
|
+
};
|
193
|
+
|
194
|
+
class V8_PLATFORM_EXPORT TraceConfig {
|
195
|
+
public:
|
196
|
+
typedef std::vector<std::string> StringList;
|
197
|
+
|
198
|
+
static TraceConfig* CreateDefaultTraceConfig();
|
199
|
+
|
200
|
+
TraceConfig() : enable_systrace_(false), enable_argument_filter_(false) {}
|
201
|
+
TraceRecordMode GetTraceRecordMode() const { return record_mode_; }
|
202
|
+
const StringList& GetEnabledCategories() const {
|
203
|
+
return included_categories_;
|
204
|
+
}
|
205
|
+
bool IsSystraceEnabled() const { return enable_systrace_; }
|
206
|
+
bool IsArgumentFilterEnabled() const { return enable_argument_filter_; }
|
207
|
+
|
208
|
+
void SetTraceRecordMode(TraceRecordMode mode) { record_mode_ = mode; }
|
209
|
+
void EnableSystrace() { enable_systrace_ = true; }
|
210
|
+
void EnableArgumentFilter() { enable_argument_filter_ = true; }
|
211
|
+
|
212
|
+
void AddIncludedCategory(const char* included_category);
|
213
|
+
|
214
|
+
bool IsCategoryGroupEnabled(const char* category_group) const;
|
215
|
+
|
216
|
+
private:
|
217
|
+
TraceRecordMode record_mode_;
|
218
|
+
bool enable_systrace_ : 1;
|
219
|
+
bool enable_argument_filter_ : 1;
|
220
|
+
StringList included_categories_;
|
221
|
+
|
222
|
+
// Disallow copy and assign
|
223
|
+
TraceConfig(const TraceConfig&) = delete;
|
224
|
+
void operator=(const TraceConfig&) = delete;
|
225
|
+
};
|
226
|
+
|
227
|
+
#if defined(_MSC_VER)
|
228
|
+
#define V8_PLATFORM_NON_EXPORTED_BASE(code) \
|
229
|
+
__pragma(warning(suppress : 4275)) code
|
230
|
+
#else
|
231
|
+
#define V8_PLATFORM_NON_EXPORTED_BASE(code) code
|
232
|
+
#endif // defined(_MSC_VER)
|
233
|
+
|
234
|
+
class V8_PLATFORM_EXPORT TracingController
|
235
|
+
: public V8_PLATFORM_NON_EXPORTED_BASE(v8::TracingController) {
|
236
|
+
public:
|
237
|
+
TracingController();
|
238
|
+
~TracingController() override;
|
239
|
+
|
240
|
+
#if defined(V8_USE_PERFETTO)
|
241
|
+
// Must be called before StartTracing() if V8_USE_PERFETTO is true. Provides
|
242
|
+
// the output stream for the JSON trace data.
|
243
|
+
void InitializeForPerfetto(std::ostream* output_stream);
|
244
|
+
// Provide an optional listener for testing that will receive trace events.
|
245
|
+
// Must be called before StartTracing().
|
246
|
+
void SetTraceEventListenerForTesting(TraceEventListener* listener);
|
247
|
+
#else // defined(V8_USE_PERFETTO)
|
248
|
+
// The pointer returned from GetCategoryGroupEnabled() points to a value with
|
249
|
+
// zero or more of the following bits. Used in this class only. The
|
250
|
+
// TRACE_EVENT macros should only use the value as a bool. These values must
|
251
|
+
// be in sync with macro values in TraceEvent.h in Blink.
|
252
|
+
enum CategoryGroupEnabledFlags {
|
253
|
+
// Category group enabled for the recording mode.
|
254
|
+
ENABLED_FOR_RECORDING = 1 << 0,
|
255
|
+
// Category group enabled by SetEventCallbackEnabled().
|
256
|
+
ENABLED_FOR_EVENT_CALLBACK = 1 << 2,
|
257
|
+
// Category group enabled to export events to ETW.
|
258
|
+
ENABLED_FOR_ETW_EXPORT = 1 << 3
|
259
|
+
};
|
260
|
+
|
261
|
+
// Takes ownership of |trace_buffer|.
|
262
|
+
void Initialize(TraceBuffer* trace_buffer);
|
263
|
+
|
264
|
+
// v8::TracingController implementation.
|
265
|
+
const uint8_t* GetCategoryGroupEnabled(const char* category_group) override;
|
266
|
+
uint64_t AddTraceEvent(
|
267
|
+
char phase, const uint8_t* category_enabled_flag, const char* name,
|
268
|
+
const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
|
269
|
+
const char** arg_names, const uint8_t* arg_types,
|
270
|
+
const uint64_t* arg_values,
|
271
|
+
std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables,
|
272
|
+
unsigned int flags) override;
|
273
|
+
uint64_t AddTraceEventWithTimestamp(
|
274
|
+
char phase, const uint8_t* category_enabled_flag, const char* name,
|
275
|
+
const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
|
276
|
+
const char** arg_names, const uint8_t* arg_types,
|
277
|
+
const uint64_t* arg_values,
|
278
|
+
std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables,
|
279
|
+
unsigned int flags, int64_t timestamp) override;
|
280
|
+
void UpdateTraceEventDuration(const uint8_t* category_enabled_flag,
|
281
|
+
const char* name, uint64_t handle) override;
|
282
|
+
|
283
|
+
static const char* GetCategoryGroupName(const uint8_t* category_enabled_flag);
|
284
|
+
#endif // !defined(V8_USE_PERFETTO)
|
285
|
+
|
286
|
+
void AddTraceStateObserver(
|
287
|
+
v8::TracingController::TraceStateObserver* observer) override;
|
288
|
+
void RemoveTraceStateObserver(
|
289
|
+
v8::TracingController::TraceStateObserver* observer) override;
|
290
|
+
|
291
|
+
void StartTracing(TraceConfig* trace_config);
|
292
|
+
void StopTracing();
|
293
|
+
|
294
|
+
protected:
|
295
|
+
#if !defined(V8_USE_PERFETTO)
|
296
|
+
virtual int64_t CurrentTimestampMicroseconds();
|
297
|
+
virtual int64_t CurrentCpuTimestampMicroseconds();
|
298
|
+
#endif // !defined(V8_USE_PERFETTO)
|
299
|
+
|
300
|
+
private:
|
301
|
+
#if !defined(V8_USE_PERFETTO)
|
302
|
+
void UpdateCategoryGroupEnabledFlag(size_t category_index);
|
303
|
+
void UpdateCategoryGroupEnabledFlags();
|
304
|
+
#endif // !defined(V8_USE_PERFETTO)
|
305
|
+
|
306
|
+
std::unique_ptr<base::Mutex> mutex_;
|
307
|
+
std::unique_ptr<TraceConfig> trace_config_;
|
308
|
+
std::atomic_bool recording_{false};
|
309
|
+
std::unordered_set<v8::TracingController::TraceStateObserver*> observers_;
|
310
|
+
|
311
|
+
#if defined(V8_USE_PERFETTO)
|
312
|
+
std::ostream* output_stream_ = nullptr;
|
313
|
+
std::unique_ptr<perfetto::trace_processor::TraceProcessorStorage>
|
314
|
+
trace_processor_;
|
315
|
+
TraceEventListener* listener_for_testing_ = nullptr;
|
316
|
+
std::unique_ptr<perfetto::TracingSession> tracing_session_;
|
317
|
+
#else // !defined(V8_USE_PERFETTO)
|
318
|
+
std::unique_ptr<TraceBuffer> trace_buffer_;
|
319
|
+
#endif // !defined(V8_USE_PERFETTO)
|
320
|
+
|
321
|
+
// Disallow copy and assign
|
322
|
+
TracingController(const TracingController&) = delete;
|
323
|
+
void operator=(const TracingController&) = delete;
|
324
|
+
};
|
325
|
+
|
326
|
+
#undef V8_PLATFORM_NON_EXPORTED_BASE
|
327
|
+
|
328
|
+
} // namespace tracing
|
329
|
+
} // namespace platform
|
330
|
+
} // namespace v8
|
331
|
+
|
332
|
+
#endif // V8_LIBPLATFORM_V8_TRACING_H_
|
@@ -0,0 +1,226 @@
|
|
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
|
+
#ifndef INCLUDE_V8_CPPGC_H_
|
6
|
+
#define INCLUDE_V8_CPPGC_H_
|
7
|
+
|
8
|
+
#include "cppgc/visitor.h"
|
9
|
+
#include "v8-internal.h" // NOLINT(build/include_directory)
|
10
|
+
#include "v8.h" // NOLINT(build/include_directory)
|
11
|
+
|
12
|
+
namespace v8 {
|
13
|
+
|
14
|
+
class Isolate;
|
15
|
+
template <typename T>
|
16
|
+
class JSMember;
|
17
|
+
|
18
|
+
namespace internal {
|
19
|
+
|
20
|
+
class JSMemberBaseExtractor;
|
21
|
+
|
22
|
+
class V8_EXPORT JSMemberBase {
|
23
|
+
public:
|
24
|
+
/**
|
25
|
+
* Returns true if the reference is empty, i.e., has not been assigned
|
26
|
+
* object.
|
27
|
+
*/
|
28
|
+
bool IsEmpty() const { return val_ == nullptr; }
|
29
|
+
|
30
|
+
/**
|
31
|
+
* Clears the reference. IsEmpty() will return true after this call.
|
32
|
+
*/
|
33
|
+
inline void Reset();
|
34
|
+
|
35
|
+
private:
|
36
|
+
static internal::Address* New(v8::Isolate* isolate,
|
37
|
+
internal::Address* object_slot,
|
38
|
+
internal::Address** this_slot);
|
39
|
+
static void Delete(internal::Address* object);
|
40
|
+
static void Copy(const internal::Address* const* from_slot,
|
41
|
+
internal::Address** to_slot);
|
42
|
+
static void Move(internal::Address** from_slot, internal::Address** to_slot);
|
43
|
+
|
44
|
+
JSMemberBase() = default;
|
45
|
+
|
46
|
+
JSMemberBase(v8::Isolate* isolate, internal::Address* object_slot)
|
47
|
+
: val_(New(isolate, object_slot, &val_)) {}
|
48
|
+
|
49
|
+
inline JSMemberBase& CopyImpl(const JSMemberBase& other);
|
50
|
+
inline JSMemberBase& MoveImpl(JSMemberBase&& other);
|
51
|
+
|
52
|
+
// val_ points to a GlobalHandles node.
|
53
|
+
internal::Address* val_ = nullptr;
|
54
|
+
|
55
|
+
template <typename T>
|
56
|
+
friend class v8::JSMember;
|
57
|
+
friend class v8::internal::JSMemberBaseExtractor;
|
58
|
+
};
|
59
|
+
|
60
|
+
JSMemberBase& JSMemberBase::CopyImpl(const JSMemberBase& other) {
|
61
|
+
if (this != &other) {
|
62
|
+
Reset();
|
63
|
+
if (!other.IsEmpty()) {
|
64
|
+
Copy(&other.val_, &val_);
|
65
|
+
}
|
66
|
+
}
|
67
|
+
return *this;
|
68
|
+
}
|
69
|
+
|
70
|
+
JSMemberBase& JSMemberBase::MoveImpl(JSMemberBase&& other) {
|
71
|
+
if (this != &other) {
|
72
|
+
// No call to Reset() as Move() will conditionally reset itself when needed,
|
73
|
+
// and otherwise reuse the internal meta data.
|
74
|
+
Move(&other.val_, &val_);
|
75
|
+
}
|
76
|
+
return *this;
|
77
|
+
}
|
78
|
+
|
79
|
+
void JSMemberBase::Reset() {
|
80
|
+
if (IsEmpty()) return;
|
81
|
+
Delete(val_);
|
82
|
+
val_ = nullptr;
|
83
|
+
}
|
84
|
+
|
85
|
+
} // namespace internal
|
86
|
+
|
87
|
+
/**
|
88
|
+
* A traced handle without destructor that clears the handle. The handle may
|
89
|
+
* only be used in GarbageCollected objects and must be processed in a Trace()
|
90
|
+
* method.
|
91
|
+
*/
|
92
|
+
template <typename T>
|
93
|
+
class V8_EXPORT JSMember : public internal::JSMemberBase {
|
94
|
+
static_assert(std::is_base_of<v8::Value, T>::value,
|
95
|
+
"JSMember only supports references to v8::Value");
|
96
|
+
|
97
|
+
public:
|
98
|
+
JSMember() = default;
|
99
|
+
|
100
|
+
template <typename U,
|
101
|
+
typename = std::enable_if_t<std::is_base_of<T, U>::value>>
|
102
|
+
JSMember(Isolate* isolate, Local<U> that)
|
103
|
+
: internal::JSMemberBase(isolate,
|
104
|
+
reinterpret_cast<internal::Address*>(*that)) {}
|
105
|
+
|
106
|
+
JSMember(const JSMember& other) { CopyImpl(other); }
|
107
|
+
|
108
|
+
template <typename U,
|
109
|
+
typename = std::enable_if_t<std::is_base_of<T, U>::value>>
|
110
|
+
JSMember(const JSMember<U>& other) { // NOLINT
|
111
|
+
CopyImpl(other);
|
112
|
+
}
|
113
|
+
|
114
|
+
JSMember(JSMember&& other) { MoveImpl(std::move(other)); }
|
115
|
+
|
116
|
+
template <typename U,
|
117
|
+
typename = std::enable_if_t<std::is_base_of<T, U>::value>>
|
118
|
+
JSMember(JSMember<U>&& other) { // NOLINT
|
119
|
+
MoveImpl(std::move(other));
|
120
|
+
}
|
121
|
+
|
122
|
+
JSMember& operator=(const JSMember& other) { return CopyImpl(other); }
|
123
|
+
|
124
|
+
template <typename U,
|
125
|
+
typename = std::enable_if_t<std::is_base_of<T, U>::value>>
|
126
|
+
JSMember& operator=(const JSMember<U>& other) {
|
127
|
+
return CopyImpl(other);
|
128
|
+
}
|
129
|
+
|
130
|
+
JSMember& operator=(JSMember&& other) { return MoveImpl(other); }
|
131
|
+
|
132
|
+
template <typename U,
|
133
|
+
typename = std::enable_if_t<std::is_base_of<T, U>::value>>
|
134
|
+
JSMember& operator=(JSMember<U>&& other) {
|
135
|
+
return MoveImpl(other);
|
136
|
+
}
|
137
|
+
|
138
|
+
T* operator->() const { return reinterpret_cast<T*>(val_); }
|
139
|
+
T* operator*() const { return reinterpret_cast<T*>(val_); }
|
140
|
+
|
141
|
+
using internal::JSMemberBase::Reset;
|
142
|
+
|
143
|
+
template <typename U,
|
144
|
+
typename = std::enable_if_t<std::is_base_of<T, U>::value>>
|
145
|
+
void Set(v8::Isolate* isolate, Local<U> that) {
|
146
|
+
Reset();
|
147
|
+
val_ = New(isolate, reinterpret_cast<internal::Address*>(*that), &val_);
|
148
|
+
}
|
149
|
+
};
|
150
|
+
|
151
|
+
template <typename T1, typename T2,
|
152
|
+
typename = std::enable_if_t<std::is_base_of<T2, T1>::value ||
|
153
|
+
std::is_base_of<T1, T2>::value>>
|
154
|
+
inline bool operator==(const JSMember<T1>& lhs, const JSMember<T2>& rhs) {
|
155
|
+
v8::internal::Address* a = reinterpret_cast<v8::internal::Address*>(*lhs);
|
156
|
+
v8::internal::Address* b = reinterpret_cast<v8::internal::Address*>(*rhs);
|
157
|
+
if (a == nullptr) return b == nullptr;
|
158
|
+
if (b == nullptr) return false;
|
159
|
+
return *a == *b;
|
160
|
+
}
|
161
|
+
|
162
|
+
template <typename T1, typename T2,
|
163
|
+
typename = std::enable_if_t<std::is_base_of<T2, T1>::value ||
|
164
|
+
std::is_base_of<T1, T2>::value>>
|
165
|
+
inline bool operator!=(const JSMember<T1>& lhs, const JSMember<T2>& rhs) {
|
166
|
+
return !(lhs == rhs);
|
167
|
+
}
|
168
|
+
|
169
|
+
template <typename T1, typename T2,
|
170
|
+
typename = std::enable_if_t<std::is_base_of<T2, T1>::value ||
|
171
|
+
std::is_base_of<T1, T2>::value>>
|
172
|
+
inline bool operator==(const JSMember<T1>& lhs, const Local<T2>& rhs) {
|
173
|
+
v8::internal::Address* a = reinterpret_cast<v8::internal::Address*>(*lhs);
|
174
|
+
v8::internal::Address* b = reinterpret_cast<v8::internal::Address*>(*rhs);
|
175
|
+
if (a == nullptr) return b == nullptr;
|
176
|
+
if (b == nullptr) return false;
|
177
|
+
return *a == *b;
|
178
|
+
}
|
179
|
+
|
180
|
+
template <typename T1, typename T2,
|
181
|
+
typename = std::enable_if_t<std::is_base_of<T2, T1>::value ||
|
182
|
+
std::is_base_of<T1, T2>::value>>
|
183
|
+
inline bool operator==(const Local<T1>& lhs, const JSMember<T2> rhs) {
|
184
|
+
return rhs == lhs;
|
185
|
+
}
|
186
|
+
|
187
|
+
template <typename T1, typename T2>
|
188
|
+
inline bool operator!=(const JSMember<T1>& lhs, const T2& rhs) {
|
189
|
+
return !(lhs == rhs);
|
190
|
+
}
|
191
|
+
|
192
|
+
template <typename T1, typename T2>
|
193
|
+
inline bool operator!=(const T1& lhs, const JSMember<T2>& rhs) {
|
194
|
+
return !(lhs == rhs);
|
195
|
+
}
|
196
|
+
|
197
|
+
class JSVisitor : public cppgc::Visitor {
|
198
|
+
public:
|
199
|
+
explicit JSVisitor(cppgc::Visitor::Key key) : cppgc::Visitor(key) {}
|
200
|
+
|
201
|
+
template <typename T>
|
202
|
+
void Trace(const JSMember<T>& ref) {
|
203
|
+
if (ref.IsEmpty()) return;
|
204
|
+
Visit(ref);
|
205
|
+
}
|
206
|
+
|
207
|
+
protected:
|
208
|
+
using cppgc::Visitor::Visit;
|
209
|
+
|
210
|
+
virtual void Visit(const internal::JSMemberBase& ref) {}
|
211
|
+
};
|
212
|
+
|
213
|
+
} // namespace v8
|
214
|
+
|
215
|
+
namespace cppgc {
|
216
|
+
|
217
|
+
template <typename T>
|
218
|
+
struct TraceTrait<v8::JSMember<T>> {
|
219
|
+
static void Trace(Visitor* visitor, const v8::JSMember<T>* self) {
|
220
|
+
static_cast<v8::JSVisitor*>(visitor)->Trace(*self);
|
221
|
+
}
|
222
|
+
};
|
223
|
+
|
224
|
+
} // namespace cppgc
|
225
|
+
|
226
|
+
#endif // INCLUDE_V8_CPPGC_H_
|