Lines Matching defs:Isolate
85 class Isolate;
137 class Isolate;
150 class Isolate;
305 V8_INLINE static Local<T> New(Isolate* isolate, Local<T> that);
306 V8_INLINE static Local<T> New(Isolate* isolate,
324 friend Local<Primitive> Undefined(Isolate* isolate);
325 friend Local<Primitive> Null(Isolate* isolate);
326 friend Local<Boolean> True(Isolate* isolate);
327 friend Local<Boolean> False(Isolate* isolate);
337 V8_INLINE static Local<T> New(Isolate* isolate, T* that);
390 // Eternal handles are set-once handles that live for the life of the isolate.
395 V8_INLINE Eternal(Isolate* isolate, Local<S> handle) : index_(kInitialValue) {
396 Set(isolate, handle);
399 V8_INLINE Local<T> Get(Isolate* isolate);
401 template<class S> V8_INLINE void Set(Isolate* isolate, Local<S> handle);
417 WeakCallbackInfo(Isolate* isolate, T* parameter,
420 : isolate_(isolate), parameter_(parameter), callback_(callback) {
426 V8_INLINE Isolate* GetIsolate() const { return isolate_; }
453 Isolate* isolate_;
492 V8_INLINE void Reset(Isolate* isolate, const Local<S>& other);
499 V8_INLINE void Reset(Isolate* isolate, const PersistentBase<S>& other);
504 V8_INLINE Local<T> Get(Isolate* isolate) const {
505 return Local<T>::New(isolate, *this);
552 * A related function Isolate::NumberOfPhantomHandleResetsSinceLastCall
568 V8_INLINE void RegisterExternalReference(Isolate* isolate) const;
618 friend class Isolate;
634 V8_INLINE static T* New(Isolate* isolate, T* that);
699 V8_INLINE Persistent(Isolate* isolate, Local<S> that)
700 : PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
709 V8_INLINE Persistent(Isolate* isolate, const Persistent<S, M2>& that)
710 : PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
761 friend class Isolate;
792 V8_INLINE Global(Isolate* isolate, Local<S> that)
793 : PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
802 V8_INLINE Global(Isolate* isolate, const PersistentBase<S>& that)
803 : PersistentBase<T>(PersistentBase<T>::New(isolate, that.val_)) {
866 explicit HandleScope(Isolate* isolate);
873 static int NumberOfHandles(Isolate* isolate);
875 V8_INLINE Isolate* GetIsolate() const {
876 return reinterpret_cast<Isolate*>(isolate_);
882 void Initialize(Isolate* isolate);
884 static internal::Object** CreateHandle(internal::Isolate* isolate,
888 // Uses heap_object to obtain the current Isolate.
899 internal::Isolate* isolate_;
903 // Local::New uses CreateHandle with an Isolate* parameter.
919 explicit EscapableHandleScope(Isolate* isolate);
948 SealHandleScope(Isolate* isolate);
959 internal::Isolate* isolate_;
1300 Isolate* isolate, Source* source,
1303 Isolate* isolate, Source* source,
1319 Local<Script> Compile(Isolate* isolate, Source* source,
1337 Isolate* isolate, StreamedSource* source,
1348 Local<Script> Compile(Isolate* isolate,
1402 Isolate* isolate, Source* source,
1414 Isolate* isolate, Source* source, CompileOptions options, bool is_module);
1488 static void PrintCurrentStackTrace(Isolate* isolate, FILE* out);
1544 Isolate* isolate,
1648 MaybeLocal<Value> Parse(Isolate* isolate,
1673 static Local<NativeWeakMap> New(Isolate* isolate);
1972 Local<Boolean> ToBoolean(Isolate* isolate) const);
1974 Local<Number> ToNumber(Isolate* isolate) const);
1976 Local<String> ToString(Isolate* isolate) const);
1978 Local<String> ToDetailString(Isolate* isolate) const);
1980 Local<Object> ToObject(Isolate* isolate) const);
1982 Local<Integer> ToInteger(Isolate* isolate) const);
1984 Local<Uint32> ToUint32(Isolate* isolate) const);
1986 Local<Int32> ToInt32(Isolate* isolate) const);
2031 Local<String> TypeOf(v8::Isolate*);
2057 V8_INLINE static Local<Boolean> New(Isolate* isolate, bool value);
2178 V8_INLINE static v8::Local<v8::String> Empty(Isolate* isolate);
2301 Local<String> NewFromUtf8(Isolate* isolate, const char* data,
2308 Isolate* isolate, const char* data, v8::NewStringType type,
2314 Local<String> NewFromOneByte(Isolate* isolate, const uint8_t* data,
2321 Isolate* isolate, const uint8_t* data, v8::NewStringType type,
2327 Local<String> NewFromTwoByte(Isolate* isolate, const uint16_t* data,
2334 Isolate* isolate, const uint16_t* data, v8::NewStringType type,
2353 Isolate* isolate, ExternalStringResource* resource));
2355 Isolate* isolate, ExternalStringResource* resource);
2378 Local<String> NewExternal(Isolate* isolate,
2381 Isolate* isolate, ExternalOneByteStringResource* resource);
2463 static Local<Symbol> New(Isolate* isolate,
2471 static Local<Symbol> For(Isolate *isolate, Local<String> name);
2475 static Local<Symbol> ForApi(Isolate *isolate, Local<String> name);
2478 static Local<Symbol> GetIterator(Isolate* isolate);
2479 static Local<Symbol> GetUnscopables(Isolate* isolate);
2480 static Local<Symbol> GetToStringTag(Isolate* isolate);
2481 static Local<Symbol> GetIsConcatSpreadable(Isolate* isolate);
2502 static Local<Private> New(Isolate* isolate,
2506 // been retrieved in the same isolate before, it is created.
2512 static Local<Private> ForApi(Isolate* isolate, Local<String> name);
2525 static Local<Number> New(Isolate* isolate, double value);
2538 static Local<Integer> New(Isolate* isolate, int32_t value);
2539 static Local<Integer> NewFromUnsigned(Isolate* isolate, uint32_t value);
2978 // TODO(dcarney): take an isolate and optionally bail out?
3021 * Return the isolate to which the Object belongs to.
3023 V8_DEPRECATE_SOON("Keep track of isolate correctly", Isolate* GetIsolate());
3025 static Local<Object> New(Isolate* isolate);
3058 static Local<Array> New(Isolate* isolate, int length = 0);
3093 static Local<Map> New(Isolate* isolate);
3125 static Local<Set> New(Isolate* isolate);
3159 // Convenience getter for Isolate
3160 V8_INLINE Isolate* GetIsolate() const;
3202 V8_INLINE Isolate* GetIsolate() const;
3234 V8_INLINE Isolate* GetIsolate() const;
3279 Local<Function> New(Isolate* isolate, FunctionCallback callback,
3372 Local<Resolver> New(Isolate* isolate));
3480 * Isolate::CreateParams.
3485 * Isolate::AdjustAmountOfExternalAllocatedMemory) is handed over to the
3522 * Allocator::Allocate that is set via Isolate::CreateParams.
3552 static Local<ArrayBuffer> New(Isolate* isolate, size_t byte_length);
3561 Isolate* isolate, void* data, size_t byte_length,
3590 * that has been set via Isolate::CreateParams.
3885 * v8::Isolate::CreateParams::array_buffer_allocator.
3915 static Local<SharedArrayBuffer> New(Isolate* isolate, size_t byte_length);
3924 Isolate* isolate, void* data, size_t byte_length,
3942 * v8::Isolate::CreateParams::array_buffer_allocator.
3957 * v8::Isolate::CreateParams::array_buffer_allocator.
3977 Local<Value> New(Isolate* isolate, double time));
4001 static void DateTimeConfigurationChangeNotification(Isolate* isolate);
4013 static Local<Value> New(Isolate* isolate, double value);
4029 static Local<Value> New(Isolate* isolate, bool value);
4030 V8_DEPRECATED("Pass an isolate", static Local<Value> New(bool value));
4064 static Local<Value> New(Isolate* isolate, Local<Symbol> value);
4134 static Local<External> New(Isolate* isolate, void* value);
4166 V8_INLINE void Set(Isolate* isolate, const char* name, Local<Data> value);
4489 Isolate* isolate, FunctionCallback callback = 0,
4495 static Local<FunctionTemplate> FromSnapshot(Isolate* isolate, size_t index);
4502 Isolate* isolate, FunctionCallback callback,
4668 Isolate* isolate,
4670 static V8_DEPRECATED("Use isolate version", Local<ObjectTemplate> New());
4673 static Local<ObjectTemplate> FromSnapshot(Isolate* isolate, size_t index);
4832 static Local<ObjectTemplate> New(internal::Isolate* isolate,
4844 Isolate* isolate,
4859 Isolate* isolate,
4897 v8::Isolate* isolate, v8::Local<v8::String> name) {
4929 V8_INLINE Local<Primitive> Undefined(Isolate* isolate);
4930 V8_INLINE Local<Primitive> Null(Isolate* isolate);
4931 V8_INLINE Local<Boolean> True(Isolate* isolate);
4932 V8_INLINE Local<Boolean> False(Isolate* isolate);
5020 static Local<Message> CreateMessage(Isolate* isolate, Local<Value> exception);
5021 V8_DEPRECATED("Use version with an Isolate*",
5062 typedef void (*BeforeCallEnteredCallback)(Isolate*);
5063 typedef void (*CallCompletedCallback)(Isolate*);
5100 typedef void (*MicrotasksCompletedCallback)(Isolate*);
5106 * - explicit: microtasks are invoked with Isolate::RunMicrotasks() method;
5116 * is used on Isolate. In this mode every non-primitive call to V8 should be
5127 MicrotasksScope(Isolate* isolate, Type type);
5133 static void PerformCheckpoint(Isolate* isolate);
5138 static int GetCurrentDepth(Isolate* isolate);
5143 static bool IsRunningMicrotasks(Isolate* isolate);
5146 internal::Isolate* const isolate_;
5208 typedef void (*InterruptCallback)(Isolate* isolate, void* data);
5240 friend class Isolate;
5260 friend class Isolate;
5278 friend class Isolate;
5291 friend class Isolate;
5511 * Isolate represents an isolated instance of the V8 engine. V8 isolates have
5512 * completely separate states. Objects from one isolate must not be used in
5514 * parallel in multiple threads. An isolate can be entered by at most one
5518 class V8_EXPORT Isolate {
5521 * Initial configuration parameters for a new Isolate.
5550 * ResourceConstraints to use for the new Isolate.
5585 * entire lifetime of the isolate.
5592 * Stack-allocated class which sets the isolate for all operations
5597 explicit Scope(Isolate* isolate) : isolate_(isolate) {
5598 isolate->Enter();
5604 Isolate* const isolate_;
5619 DisallowJavascriptExecutionScope(Isolate* isolate, OnFailure on_failure);
5638 explicit AllowJavascriptExecutionScope(Isolate* isolate);
5657 explicit SuppressMicrotaskExecutionScope(Isolate* isolate);
5661 internal::Isolate* isolate_;
5725 typedef void (*UseCounterCallback)(Isolate* isolate,
5730 * Creates a new isolate. Does not change the currently entered
5731 * isolate.
5733 * When an isolate is no longer used its resources should be freed
5738 static Isolate* New(const CreateParams& params);
5741 * Returns the entered isolate for the current thread or NULL in
5742 * case there is no current isolate.
5746 static Isolate* GetCurrent();
5757 typedef bool (*AbortOnUncaughtExceptionCallback)(Isolate*);
5765 * the isolate is executing long running JavaScript code.
5775 * Sets this isolate as the entered one for the current thread.
5777 * restored when exiting. Re-entering an isolate is allowed.
5782 * Exits this isolate by restoring the previously entered one in the
5783 * current thread. The isolate may still stay the same, if it was
5786 * Requires: this == Isolate::GetCurrent().
5791 * Disposes the isolate. The isolate must not be entered by any
5797 * Discards all V8 thread-specific data for the Isolate. Should be used
5798 * if a thread is terminating and it has used an Isolate that will outlive
5799 * the thread -- all thread-specific data for an Isolate is discarded when
5800 * an Isolate is disposed so this call is pointless if an Isolate is about
5806 * Associate embedder-specific data with the isolate. |slot| has to be
5812 * Retrieve embedder-specific data from the isolate.
5872 * Get a call stack sample from the isolate.
5909 * Returns heap profiler for this isolate. Will return NULL until the isolate
5915 * Returns CPU profiler for this isolate. Will return NULL unless the isolate
5921 /** Returns true if this isolate has a current context. */
5984 typedef void (*GCCallback)(Isolate* isolate, GCType type,
6006 * Sets the embedder heap tracer for the isolate.
6030 * in the given isolate.
6048 * Resume execution capability in the given isolate, whose execution
6052 * the isolate can not resume execution until all JavaScript frames
6069 * Registered |callback| must not reenter interrupted Isolate.
6074 * Request garbage collection in this Isolate. It is only valid to call this
6237 * Optional notification that the isolate switched to the foreground.
6243 * Optional notification that the isolate switched to the background.
6276 * \note Use Isolate::CreateParams to get events for code executed during
6277 * Isolate setup.
6283 * Modifies the stack limit for this Isolate.
6353 * Iterates through all external resources referenced from current isolate
6360 * Iterates through all the persistent handles in the current isolate's heap
6366 * Iterates through all the persistent handles in the current isolate's heap
6375 * Iterates through all the persistent handles in the current isolate's heap
6382 * Check if this isolate is in use.
6383 * True if at least one thread Enter'ed this isolate.
6391 Isolate();
6392 Isolate(const Isolate&);
6393 ~Isolate();
6394 Isolate& operator=(const Isolate&);
6442 "Use isolate version",
6450 "Use isolate version", void SetAllowCodeGenerationFromStringsCallback(
6457 V8_INLINE static V8_DEPRECATED("Use isolate version", bool IsDead());
6478 * Bootstrap an isolate and a context from scratch to create a startup
6486 * Bootstrap an isolate and a context from the cold startup blob, run the
6506 "Use isolate version",
6514 "Use isolate version", void RemoveMessageListeners(MessageCallback that));
6521 "Use isolate version",
6543 "Use isolate version",
6557 "Use isolate version",
6566 "Use isolate version",
6580 "Use isolate version",
6589 "Use isolate version",
6593 * Initializes V8. This function needs to be called before the first Isolate
6613 * in the given isolate.
6618 * \param isolate The isolate in which to terminate the current JS execution.
6620 V8_INLINE static V8_DEPRECATED("Use isolate version",
6621 void TerminateExecution(Isolate* isolate));
6631 * \param isolate The isolate in which to check.
6634 "Use isolate version",
6635 bool IsExecutionTerminating(Isolate* isolate = NULL));
6638 * Resume execution capability in the given isolate, whose execution
6642 * the isolate can not resume execution until all JavaScript frames
6651 * \param isolate The isolate in which to resume execution capability.
6654 "Use isolate version", void CancelTerminateExecution(Isolate* isolate));
6668 * Iterates through all external resources referenced from current isolate
6673 "Use isolate version",
6677 * Iterates through all the persistent handles in the current isolate's heap
6681 "Use isolate version",
6685 * Iterates through all the persistent handles in isolate's heap that have
6689 "Use isolate version",
6690 void VisitHandlesWithClassIds(Isolate* isolate,
6694 * Iterates through all the persistent handles in the current isolate's heap
6701 "Use isolate version",
6702 void VisitHandlesForPartialDependence(Isolate* isolate,
6765 static internal::Object** GlobalizeReference(internal::Isolate* isolate,
6780 static void Eternalize(Isolate* isolate,
6783 static Local<Value> GetEternal(Isolate* isolate, int index);
6786 internal::Isolate* isolate);
6814 * Create and enter an isolate, and set it up for serialization.
6815 * The isolate is either created from scratch or from an existing snapshot.
6827 * \returns the isolate prepared by the snapshot creator.
6829 Isolate* GetIsolate();
6932 V8_DEPRECATED("Use isolate version", TryCatch());
6939 TryCatch(Isolate* isolate);
7063 v8::internal::Isolate* isolate_;
7074 friend class v8::internal::Isolate;
7129 * \param isolate The isolate in which to create the context.
7144 Isolate* isolate, ExtensionConfiguration* extensions = NULL,
7175 /** Returns an isolate associated with a current context. */
7176 v8::Isolate* GetIsolate();
7283 * to use any given V8 isolate, see the comments in the Isolate class. The
7284 * definition of 'using a V8 isolate' includes accessing handles or holding onto
7285 * object pointers obtained from V8 handles while in the particular V8 isolate.
7293 * isolate. V8 guarantees that an isolate can be locked by at most one thread at
7300 * v8::Locker locker(isolate);
7301 * v8::Isolate::Scope isolate_scope(isolate);
7303 * // Code using V8 and isolate goes here.
7314 * isolate->Exit();
7315 * v8::Unlocker unlocker(isolate);
7320 * isolate->Enter();
7338 * v8::Locker locker(isolate);
7339 * Isolate::Scope isolate_scope(isolate);
7342 * v8::Locker another_locker(isolate);
7345 * isolate->Exit();
7346 * v8::Unlocker unlocker(isolate);
7349 * isolate->Enter();
7360 * Initialize Unlocker for a given Isolate.
7362 V8_INLINE explicit Unlocker(Isolate* isolate) { Initialize(isolate); }
7366 void Initialize(Isolate* isolate);
7368 internal::Isolate* isolate_;
7375 * Initialize Locker for a given Isolate.
7377 V8_INLINE explicit Locker(Isolate* isolate) { Initialize(isolate); }
7382 * Returns whether or not the locker for a given isolate, is locked by the
7385 static bool IsLocked(Isolate* isolate);
7393 void Initialize(Isolate* isolate);
7397 internal::Isolate* isolate_;
7548 V8_EXPORT static void CheckInitializedImpl(v8::Isolate* isolate);
7549 V8_INLINE static void CheckInitialized(v8::Isolate* isolate) {
7551 CheckInitializedImpl(isolate);
7613 V8_INLINE static void SetEmbedderData(v8::Isolate* isolate,
7616 uint8_t* addr = reinterpret_cast<uint8_t*>(isolate) +
7621 V8_INLINE static void* GetEmbedderData(const v8::Isolate* isolate,
7623 const uint8_t* addr = reinterpret_cast<const uint8_t*>(isolate) +
7628 V8_INLINE static internal::Object** GetRoot(v8::Isolate* isolate,
7630 uint8_t* addr = reinterpret_cast<uint8_t*>(isolate) + kIsolateRootsOffset;
7659 Local<T> Local<T>::New(Isolate* isolate, Local<T> that) {
7660 return New(isolate, that.val_);
7664 Local<T> Local<T>::New(Isolate* isolate, const PersistentBase<T>& that) {
7665 return New(isolate, that.val_);
7670 Local<T> Local<T>::New(Isolate* isolate, T* that) {
7675 reinterpret_cast<internal::Isolate*>(isolate), *p)));
7681 void Eternal<T>::Set(Isolate* isolate, Local<S> handle) {
7683 V8::Eternalize(isolate, reinterpret_cast<Value*>(*handle), &this->index_);
7688 Local<T> Eternal<T>::Get(Isolate* isolate) {
7689 return Local<T>(reinterpret_cast<T*>(*V8::GetEternal(isolate, index_)));
7712 T* PersistentBase<T>::New(Isolate* isolate, T* that) {
7716 V8::GlobalizeReference(reinterpret_cast<internal::Isolate*>(isolate),
7772 void PersistentBase<T>::Reset(Isolate* isolate, const Local<S>& other) {
7776 this->val_ = New(isolate, other.val_);
7782 void PersistentBase<T>::Reset(Isolate* isolate,
7787 this->val_ = New(isolate, other.val_);
7814 void PersistentBase<T>::RegisterExternalReference(Isolate* isolate
7818 reinterpret_cast<internal::Isolate*>(isolate));
7970 Isolate* ReturnValue<T>::GetIsolate() const {
7971 // Isolate is always the pointer below the default value on the stack.
7972 return *reinterpret_cast<Isolate**>(&value_[-2]);
8041 Isolate* FunctionCallbackInfo<T>::GetIsolate() const {
8042 return *reinterpret_cast<Isolate**>(&implicit_args_[kIsolateIndex]);
8128 Local<Boolean> Boolean::New(Isolate* isolate, bool value) {
8129 return value ? True(isolate) : False(isolate);
8133 void Template::Set(Isolate* isolate, const char* name, v8::Local<Data> value) {
8134 Set(v8::String::NewFromUtf8(isolate, name, NewStringType::kNormal)
8187 Local<String> String::Empty(Isolate* isolate) {
8190 I::CheckInitialized(isolate);
8191 S* slot = I::GetRoot(isolate, I::kEmptyStringRootIndex);
8293 return ToBoolean(Isolate::GetCurrent()->GetCurrentContext())
8299 return ToNumber(Isolate::GetCurrent()->GetCurrentContext())
8305 return ToString(Isolate::GetCurrent()->GetCurrentContext())
8311 return ToDetailString(Isolate::GetCurrent()->GetCurrentContext())
8317 return ToObject(Isolate::GetCurrent()->GetCurrentContext())
8323 return ToInteger(Isolate::GetCurrent()->GetCurrentContext())
8329 return ToUint32(Isolate::GetCurrent()->GetCurrentContext())
8335 return ToInt32(Isolate::GetCurrent()->GetCurrentContext())
8629 Isolate* PropertyCallbackInfo<T>::GetIsolate() const {
8630 return *reinterpret_cast<Isolate**>(&args_[kIsolateIndex]);
8664 Local<Primitive> Undefined(Isolate* isolate) {
8667 I::CheckInitialized(isolate);
8668 S* slot = I::GetRoot(isolate, I::kUndefinedValueRootIndex);
8673 Local<Primitive> Null(Isolate* isolate) {
8676 I::CheckInitialized(isolate);
8677 S* slot = I::GetRoot(isolate, I::kNullValueRootIndex);
8682 Local<Boolean> True(Isolate* isolate) {
8685 I::CheckInitialized(isolate);
8686 S* slot = I::GetRoot(isolate, I::kTrueValueRootIndex);
8691 Local<Boolean> False(Isolate* isolate) {
8694 I::CheckInitialized(isolate);
8695 S* slot = I::GetRoot(isolate, I::kFalseValueRootIndex);
8700 void Isolate::SetData(uint32_t slot, void* data) {
8706 void* Isolate::GetData(uint32_t slot) {
8712 uint32_t Isolate::GetNumberOfDataSlots() {
8718 int64_t Isolate::AdjustAmountOfExternalAllocatedMemory(
8735 void Isolate::SetObjectGroupId(const Persistent<T>& object,
8743 void Isolate::SetReferenceFromGroup(UniqueId id,
8752 void Isolate::SetReference(const Persistent<T>& parent,
8788 Isolate* isolate = Isolate::GetCurrent();
8789 isolate->SetAllowCodeGenerationFromStringsCallback(callback);
8794 Isolate* isolate = Isolate::GetCurrent();
8795 return isolate->IsDead();
8800 Isolate* isolate = Isolate::GetCurrent();
8801 return isolate->AddMessageListener(that, data);
8806 Isolate* isolate = Isolate::GetCurrent();
8807 isolate->RemoveMessageListeners(that);
8813 Isolate* isolate = Isolate::GetCurrent();
8814 isolate->SetFailedAccessCheckCallbackFunction(callback);
8820 Isolate* isolate = Isolate::GetCurrent();
8821 isolate->SetCaptureStackTraceForUncaughtExceptions(capture, frame_limit,
8827 Isolate* isolate = Isolate::GetCurrent();
8828 isolate->SetFatalErrorHandler(callback);
8833 Isolate* isolate = Isolate::GetCurrent();
8834 isolate->RemoveGCPrologueCallback(
8835 reinterpret_cast<v8::Isolate::GCCallback>(callback));
8840 Isolate* isolate = Isolate::GetCurrent();
8841 isolate->RemoveGCEpilogueCallback(
8842 reinterpret_cast<v8::Isolate::GCCallback>(callback));
8845 void V8::TerminateExecution(Isolate* isolate) { isolate->TerminateExecution(); }
8848 bool V8::IsExecutionTerminating(Isolate* isolate) {
8849 if (isolate == NULL) {
8850 isolate = Isolate::GetCurrent();
8852 return isolate->IsExecutionTerminating();
8856 void V8::CancelTerminateExecution(Isolate* isolate) {
8857 isolate->CancelTerminateExecution();
8862 Isolate* isolate = Isolate::GetCurrent();
8863 isolate->VisitExternalResources(visitor);
8868 Isolate* isolate = Isolate::GetCurrent();
8869 isolate->VisitHandlesWithClassIds(visitor);
8873 void V8::VisitHandlesWithClassIds(Isolate* isolate,
8875 isolate->VisitHandlesWithClassIds(visitor);
8879 void V8::VisitHandlesForPartialDependence(Isolate* isolate,
8881 isolate->VisitHandlesForPartialDependence(visitor);
