v8-persistent-handle.h

Go to the documentation of this file.

// Copyright 2021 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 INCLUDE_V8_PERSISTENT_HANDLE_H_
#define INCLUDE_V8_PERSISTENT_HANDLE_H_
 
#include "v8-internal.h"            // NOLINT(build/include_directory)
#include "v8-local-handle.h"        // NOLINT(build/include_directory)
#include "v8-weak-callback-info.h"  // NOLINT(build/include_directory)
#include "v8config.h"               // NOLINT(build/include_directory)
 
namespace v8 {
 
class Isolate;
template <class K, class V, class T>
class PersistentValueMapBase;
template <class V, class T>
class PersistentValueVector;
template <class T>
class Global;
template <class T>
class PersistentBase;
template <class K, class V, class T>
class PersistentValueMap;
class Value;
 
namespace api_internal {
V8_EXPORT internal::Address* Eternalize(v8::Isolate* isolate, Value* handle);
V8_EXPORT internal::Address* CopyGlobalReference(internal::Address* from);
V8_EXPORT void DisposeGlobal(internal::Address* global_handle);
V8_EXPORT void MakeWeak(internal::Address** location_addr);
V8_EXPORT void* ClearWeak(internal::Address* location);
V8_EXPORT void AnnotateStrongRetainer(internal::Address* location,
                                      const char* label);
V8_EXPORT internal::Address* GlobalizeReference(internal::Isolate* isolate,
                                                internal::Address value);
V8_EXPORT void MoveGlobalReference(internal::Address** from,
                                   internal::Address** to);
}  // namespace api_internal
 
template <class T>
class Eternal : public api_internal::IndirectHandleBase {
 public:
  V8_INLINE Eternal() = default;
 
  template <class S>
  V8_INLINE Eternal(Isolate* isolate, Local<S> handle) {
    Set(isolate, handle);
  }
 
  // Can only be safely called if already set.
  V8_INLINE Local<T> Get(Isolate* isolate) const {
    // The eternal handle will never go away, so as with the roots, we don't
    // even need to open a handle.
    return Local<T>::FromSlot(slot());
  }
 
  template <class S>
  void Set(Isolate* isolate, Local<S> handle) {
    static_assert(std::is_base_of<T, S>::value, "type check");
    slot() =
        api_internal::Eternalize(isolate, *handle.template UnsafeAs<Value>());
  }
};
 
namespace api_internal {
V8_EXPORT void MakeWeak(internal::Address* location, void* data,
                        WeakCallbackInfo<void>::Callback weak_callback,
                        WeakCallbackType type);
}  // namespace api_internal
 
template <class T>
class PersistentBase : public api_internal::IndirectHandleBase {
 public:
  V8_INLINE void Reset();
 
  template <class S>
  V8_INLINE void Reset(Isolate* isolate, const Local<S>& other);
 
  template <class S>
  V8_INLINE void Reset(Isolate* isolate, const PersistentBase<S>& other);
 
  V8_INLINE Local<T> Get(Isolate* isolate) const {
    return Local<T>::New(isolate, *this);
  }
 
  template <class S>
  V8_INLINE bool operator==(const PersistentBase<S>& that) const {
    return internal::HandleHelper::EqualHandles(*this, that);
  }
 
  template <class S>
  V8_INLINE bool operator==(const Local<S>& that) const {
    return internal::HandleHelper::EqualHandles(*this, that);
  }
 
  template <class S>
  V8_INLINE bool operator!=(const PersistentBase<S>& that) const {
    return !operator==(that);
  }
 
  template <class S>
  V8_INLINE bool operator!=(const Local<S>& that) const {
    return !operator==(that);
  }
 
  template <typename P>
  V8_INLINE void SetWeak(P* parameter,
                         typename WeakCallbackInfo<P>::Callback callback,
                         WeakCallbackType type);
 
  V8_INLINE void SetWeak();
 
  template <typename P>
  V8_INLINE P* ClearWeak();
 
  // TODO(dcarney): remove this.
  V8_INLINE void ClearWeak() { ClearWeak<void>(); }
 
  V8_INLINE void AnnotateStrongRetainer(const char* label);
 
  V8_INLINE bool IsWeak() const;
 
  V8_INLINE void SetWrapperClassId(uint16_t class_id);
 
  V8_INLINE uint16_t WrapperClassId() const;
 
  PersistentBase(const PersistentBase& other) = delete;
  void operator=(const PersistentBase&) = delete;
 
 private:
  friend class Isolate;
  friend class Utils;
  template <class F>
  friend class Local;
  template <class F1, class F2>
  friend class Persistent;
  template <class F>
  friend class Global;
  template <class F>
  friend class PersistentBase;
  template <class F>
  friend class ReturnValue;
  template <class F1, class F2, class F3>
  friend class PersistentValueMapBase;
  template <class F1, class F2>
  friend class PersistentValueVector;
  friend class Object;
  friend class internal::ValueHelper;
 
  V8_INLINE PersistentBase() = default;
 
  V8_INLINE explicit PersistentBase(internal::Address* location)
      : IndirectHandleBase(location) {}
 
  V8_INLINE static internal::Address* New(Isolate* isolate, T* that);
};
 
template <class T>
class NonCopyablePersistentTraits {
 public:
  using NonCopyablePersistent = Persistent<T, NonCopyablePersistentTraits<T>>;
  static const bool kResetInDestructor = false;
  template <class S, class M>
  V8_INLINE static void Copy(const Persistent<S, M>& source,
                             NonCopyablePersistent* dest) {
    static_assert(sizeof(S) < 0,
                  "NonCopyablePersistentTraits::Copy is not instantiable");
  }
};
 
template <class T, class M>
class Persistent : public PersistentBase<T> {
 public:
  V8_INLINE Persistent() = default;
 
  template <class S>
  V8_INLINE Persistent(Isolate* isolate, Local<S> that)
      : PersistentBase<T>(
            PersistentBase<T>::New(isolate, that.template value<S>())) {
    static_assert(std::is_base_of<T, S>::value, "type check");
  }
 
  template <class S, class M2>
  V8_INLINE Persistent(Isolate* isolate, const Persistent<S, M2>& that)
      : PersistentBase<T>(
            PersistentBase<T>::New(isolate, that.template value<S>())) {
    static_assert(std::is_base_of<T, S>::value, "type check");
  }
 
  V8_INLINE Persistent(const Persistent& that) : PersistentBase<T>() {
    Copy(that);
  }
  template <class S, class M2>
  V8_INLINE Persistent(const Persistent<S, M2>& that) : PersistentBase<T>() {
    Copy(that);
  }
  V8_INLINE Persistent& operator=(const Persistent& that) {
    Copy(that);
    return *this;
  }
  template <class S, class M2>
  V8_INLINE Persistent& operator=(const Persistent<S, M2>& that) {
    Copy(that);
    return *this;
  }
 
  V8_INLINE ~Persistent() {
    if (M::kResetInDestructor) this->Reset();
  }
 
  // TODO(dcarney): this is pretty useless, fix or remove
  template <class S, class M2>
  V8_INLINE static Persistent<T, M>& Cast(const Persistent<S, M2>& that) {
#ifdef V8_ENABLE_CHECKS
    // If we're going to perform the type check then we have to check
    // that the handle isn't empty before doing the checked cast.
    if (!that.IsEmpty()) T::Cast(that.template value<S>());
#endif
    return reinterpret_cast<Persistent<T, M>&>(
        const_cast<Persistent<S, M2>&>(that));
  }
 
  // TODO(dcarney): this is pretty useless, fix or remove
  template <class S, class M2>
  V8_INLINE Persistent<S, M2>& As() const {
    return Persistent<S, M2>::Cast(*this);
  }
 
 private:
  friend class Isolate;
  friend class Utils;
  template <class F>
  friend class Local;
  template <class F1, class F2>
  friend class Persistent;
  template <class F>
  friend class ReturnValue;
 
  template <class S, class M2>
  V8_INLINE void Copy(const Persistent<S, M2>& that);
};
 
template <class T>
class Global : public PersistentBase<T> {
 public:
  V8_INLINE Global() = default;
 
  template <class S>
  V8_INLINE Global(Isolate* isolate, Local<S> that)
      : PersistentBase<T>(
            PersistentBase<T>::New(isolate, that.template value<S>())) {
    static_assert(std::is_base_of<T, S>::value, "type check");
  }
 
  template <class S>
  V8_INLINE Global(Isolate* isolate, const PersistentBase<S>& that)
      : PersistentBase<T>(
            PersistentBase<T>::New(isolate, that.template value<S>())) {
    static_assert(std::is_base_of<T, S>::value, "type check");
  }
 
  V8_INLINE Global(Global&& other);
 
  V8_INLINE ~Global() { this->Reset(); }
 
  template <class S>
  V8_INLINE Global& operator=(Global<S>&& rhs);
 
  Global Pass() { return static_cast<Global&&>(*this); }
 
  /*
   * For compatibility with Chromium's base::Bind (base::Passed).
   */
  using MoveOnlyTypeForCPP03 = void;
 
  Global(const Global&) = delete;
  void operator=(const Global&) = delete;
 
 private:
  template <class F>
  friend class ReturnValue;
};
 
// UniquePersistent is an alias for Global for historical reason.
template <class T>
using UniquePersistent = Global<T>;
 
class V8_EXPORT PersistentHandleVisitor {
 public:
  virtual ~PersistentHandleVisitor() = default;
  virtual void VisitPersistentHandle(Persistent<Value>* value,
                                     uint16_t class_id) {}
};
 
template <class T>
internal::Address* PersistentBase<T>::New(Isolate* isolate, T* that) {
  if (internal::ValueHelper::IsEmpty(that)) return nullptr;
  return api_internal::GlobalizeReference(
      reinterpret_cast<internal::Isolate*>(isolate),
      internal::ValueHelper::ValueAsAddress(that));
}
 
template <class T, class M>
template <class S, class M2>
void Persistent<T, M>::Copy(const Persistent<S, M2>& that) {
  static_assert(std::is_base_of<T, S>::value, "type check");
  this->Reset();
  if (that.IsEmpty()) return;
  this->slot() = api_internal::CopyGlobalReference(that.slot());
  M::Copy(that, this);
}
 
template <class T>
bool PersistentBase<T>::IsWeak() const {
  using I = internal::Internals;
  if (this->IsEmpty()) return false;
  return I::GetNodeState(this->slot()) == I::kNodeStateIsWeakValue;
}
 
template <class T>
void PersistentBase<T>::Reset() {
  if (this->IsEmpty()) return;
  api_internal::DisposeGlobal(this->slot());
  this->Clear();
}
 
template <class T>
template <class S>
void PersistentBase<T>::Reset(Isolate* isolate, const Local<S>& other) {
  static_assert(std::is_base_of<T, S>::value, "type check");
  Reset();
  if (other.IsEmpty()) return;
  this->slot() = New(isolate, *other);
}
 
template <class T>
template <class S>
void PersistentBase<T>::Reset(Isolate* isolate,
                              const PersistentBase<S>& other) {
  static_assert(std::is_base_of<T, S>::value, "type check");
  Reset();
  if (other.IsEmpty()) return;
  this->slot() = New(isolate, other.template value<S>());
}
 
template <class T>
template <typename P>
V8_INLINE void PersistentBase<T>::SetWeak(
    P* parameter, typename WeakCallbackInfo<P>::Callback callback,
    WeakCallbackType type) {
  using Callback = WeakCallbackInfo<void>::Callback;
#if (__GNUC__ >= 8) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-function-type"
#endif
  api_internal::MakeWeak(this->slot(), parameter,
                         reinterpret_cast<Callback>(callback), type);
#if (__GNUC__ >= 8) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif
}
 
template <class T>
void PersistentBase<T>::SetWeak() {
  api_internal::MakeWeak(&this->slot());
}
 
template <class T>
template <typename P>
P* PersistentBase<T>::ClearWeak() {
  return reinterpret_cast<P*>(api_internal::ClearWeak(this->slot()));
}
 
template <class T>
void PersistentBase<T>::AnnotateStrongRetainer(const char* label) {
  api_internal::AnnotateStrongRetainer(this->slot(), label);
}
 
template <class T>
void PersistentBase<T>::SetWrapperClassId(uint16_t class_id) {
  using I = internal::Internals;
  if (this->IsEmpty()) return;
  uint8_t* addr = reinterpret_cast<uint8_t*>(slot()) + I::kNodeClassIdOffset;
  *reinterpret_cast<uint16_t*>(addr) = class_id;
}
 
template <class T>
uint16_t PersistentBase<T>::WrapperClassId() const {
  using I = internal::Internals;
  if (this->IsEmpty()) return 0;
  uint8_t* addr = reinterpret_cast<uint8_t*>(slot()) + I::kNodeClassIdOffset;
  return *reinterpret_cast<uint16_t*>(addr);
}
 
template <class T>
Global<T>::Global(Global&& other) : PersistentBase<T>(other.slot()) {
  if (!other.IsEmpty()) {
    api_internal::MoveGlobalReference(&other.slot(), &this->slot());
    other.Clear();
  }
}
 
template <class T>
template <class S>
Global<T>& Global<T>::operator=(Global<S>&& rhs) {
  static_assert(std::is_base_of<T, S>::value, "type check");
  if (this != &rhs) {
    this->Reset();
    if (!rhs.IsEmpty()) {
      this->slot() = rhs.slot();
      api_internal::MoveGlobalReference(&rhs.slot(), &this->slot());
      rhs.Clear();
    }
  }
  return *this;
}
 
}  // namespace v8
 
#endif  // INCLUDE_V8_PERSISTENT_HANDLE_H_