v8-cppgc.h

Go to the documentation of this file.

// Copyright 2020 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_CPPGC_H_
#define INCLUDE_V8_CPPGC_H_
 
#include "cppgc/visitor.h"
#include "v8-internal.h"                 // NOLINT(build/include_directory)
#include "v8.h"        // NOLINT(build/include_directory)
 
namespace v8 {
 
class Isolate;
template <typename T>
class JSMember;
 
namespace internal {
 
class JSMemberBaseExtractor;
 
class V8_EXPORT JSMemberBase {
 public:
  /**
   * Returns true if the reference is empty, i.e., has not been assigned
   * object.
   */
  bool IsEmpty() const { return val_ == nullptr; }
 
  /**
   * Clears the reference. IsEmpty() will return true after this call.
   */
  inline void Reset();
 
 private:
  static internal::Address* New(v8::Isolate* isolate,
                                internal::Address* object_slot,
                                internal::Address** this_slot);
  static void Delete(internal::Address* object);
  static void Copy(const internal::Address* const* from_slot,
                   internal::Address** to_slot);
  static void Move(internal::Address** from_slot, internal::Address** to_slot);
 
  JSMemberBase() = default;
 
  JSMemberBase(v8::Isolate* isolate, internal::Address* object_slot)
      : val_(New(isolate, object_slot, &val_)) {}
 
  inline JSMemberBase& CopyImpl(const JSMemberBase& other);
  inline JSMemberBase& MoveImpl(JSMemberBase&& other);
 
  // val_ points to a GlobalHandles node.
  internal::Address* val_ = nullptr;
 
  template <typename T>
  friend class v8::JSMember;
  friend class v8::internal::JSMemberBaseExtractor;
};
 
JSMemberBase& JSMemberBase::CopyImpl(const JSMemberBase& other) {
  if (this != &other) {
    Reset();
    if (!other.IsEmpty()) {
      Copy(&other.val_, &val_);
    }
  }
  return *this;
}
 
JSMemberBase& JSMemberBase::MoveImpl(JSMemberBase&& other) {
  if (this != &other) {
    // No call to Reset() as Move() will conditionally reset itself when needed,
    // and otherwise reuse the internal meta data.
    Move(&other.val_, &val_);
  }
  return *this;
}
 
void JSMemberBase::Reset() {
  if (IsEmpty()) return;
  Delete(val_);
  val_ = nullptr;
}
 
}  // namespace internal
 
/**
 * A traced handle without destructor that clears the handle. The handle may
 * only be used in GarbageCollected objects and must be processed in a Trace()
 * method.
 */
template <typename T>
class V8_EXPORT JSMember : public internal::JSMemberBase {
  static_assert(std::is_base_of<v8::Value, T>::value,
                "JSMember only supports references to v8::Value");
 
 public:
  JSMember() = default;
 
  template <typename U,
            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
  JSMember(Isolate* isolate, Local<U> that)
      : internal::JSMemberBase(isolate,
                               reinterpret_cast<internal::Address*>(*that)) {}
 
  JSMember(const JSMember& other) { CopyImpl(other); }
 
  template <typename U,
            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
  JSMember(const JSMember<U>& other) {  // NOLINT
    CopyImpl(other);
  }
 
  JSMember(JSMember&& other) { MoveImpl(std::move(other)); }
 
  template <typename U,
            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
  JSMember(JSMember<U>&& other) {  // NOLINT
    MoveImpl(std::move(other));
  }
 
  JSMember& operator=(const JSMember& other) { return CopyImpl(other); }
 
  template <typename U,
            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
  JSMember& operator=(const JSMember<U>& other) {
    return CopyImpl(other);
  }
 
  JSMember& operator=(JSMember&& other) { return MoveImpl(other); }
 
  template <typename U,
            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
  JSMember& operator=(JSMember<U>&& other) {
    return MoveImpl(other);
  }
 
  T* operator->() const { return reinterpret_cast<T*>(val_); }
  T* operator*() const { return reinterpret_cast<T*>(val_); }
 
  using internal::JSMemberBase::Reset;
 
  template <typename U,
            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
  void Set(v8::Isolate* isolate, Local<U> that) {
    Reset();
    val_ = New(isolate, reinterpret_cast<internal::Address*>(*that), &val_);
  }
};
 
template <typename T1, typename T2,
          typename = std::enable_if_t<std::is_base_of<T2, T1>::value ||
                                      std::is_base_of<T1, T2>::value>>
inline bool operator==(const JSMember<T1>& lhs, const JSMember<T2>& rhs) {
  v8::internal::Address* a = reinterpret_cast<v8::internal::Address*>(*lhs);
  v8::internal::Address* b = reinterpret_cast<v8::internal::Address*>(*rhs);
  if (a == nullptr) return b == nullptr;
  if (b == nullptr) return false;
  return *a == *b;
}
 
template <typename T1, typename T2,
          typename = std::enable_if_t<std::is_base_of<T2, T1>::value ||
                                      std::is_base_of<T1, T2>::value>>
inline bool operator!=(const JSMember<T1>& lhs, const JSMember<T2>& rhs) {
  return !(lhs == rhs);
}
 
template <typename T1, typename T2,
          typename = std::enable_if_t<std::is_base_of<T2, T1>::value ||
                                      std::is_base_of<T1, T2>::value>>
inline bool operator==(const JSMember<T1>& lhs, const Local<T2>& rhs) {
  v8::internal::Address* a = reinterpret_cast<v8::internal::Address*>(*lhs);
  v8::internal::Address* b = reinterpret_cast<v8::internal::Address*>(*rhs);
  if (a == nullptr) return b == nullptr;
  if (b == nullptr) return false;
  return *a == *b;
}
 
template <typename T1, typename T2,
          typename = std::enable_if_t<std::is_base_of<T2, T1>::value ||
                                      std::is_base_of<T1, T2>::value>>
inline bool operator==(const Local<T1>& lhs, const JSMember<T2> rhs) {
  return rhs == lhs;
}
 
template <typename T1, typename T2>
inline bool operator!=(const JSMember<T1>& lhs, const T2& rhs) {
  return !(lhs == rhs);
}
 
template <typename T1, typename T2>
inline bool operator!=(const T1& lhs, const JSMember<T2>& rhs) {
  return !(lhs == rhs);
}
 
class JSVisitor : public cppgc::Visitor {
 public:
  explicit JSVisitor(cppgc::Visitor::Key key) : cppgc::Visitor(key) {}
 
  template <typename T>
  void Trace(const JSMember<T>& ref) {
    if (ref.IsEmpty()) return;
    Visit(ref);
  }
 
 protected:
  using cppgc::Visitor::Visit;
 
  virtual void Visit(const internal::JSMemberBase& ref) {}
};
 
}  // namespace v8
 
namespace cppgc {
 
template <typename T>
struct TraceTrait<v8::JSMember<T>> {
  static void Trace(Visitor* visitor, const v8::JSMember<T>* self) {
    static_cast<v8::JSVisitor*>(visitor)->Trace(*self);
  }
};
 
}  // namespace cppgc
 
#endif  // INCLUDE_V8_CPPGC_H_