src: add utilities for cppgc classes

Author: joyeecheung

node.gyp

@@ -189,6 +189,7 @@
       'src/cleanup_queue-inl.h',
       'src/connect_wrap.h',
       'src/connection_wrap.h',
+      'src/cppgc_helpers.h',
       'src/dataqueue/queue.h',
       'src/debug_utils.h',
       'src/debug_utils-inl.h',

src/cppgc_helpers.h

@@ -0,0 +1,57 @@
+#ifndef SRC_CPPGC_HELPERS_H_
+#define SRC_CPPGC_HELPERS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "cppgc/garbage-collected.h"
+#include "env.h"
+#include "memory_tracker.h"
+#include "v8-cppgc.h"
+#include "v8.h"
+
+namespace node {
+
+#define ASSIGN_OR_RETURN_UNWRAP_CPPGC(ptr, obj, ...)                           \
+  do {                                                                         \
+    DCHECK_GE(obj->InternalFieldCount(), kInternalFieldCount);                 \
+    *ptr = static_cast<typename std::remove_reference<decltype(*ptr)>::type>(  \
+        obj->GetAlignedPointerFromInternalField(kSlot));                       \
+    if (*ptr == nullptr) return __VA_ARGS__;                                   \
+  } while (0)
+
+#define CPPGC_MIXIN_FIELDS()                                                   \
+  Environment* env_;                                                           \
+  v8::TracedReference<v8::Object> traced_reference_;
+
+class CppgcMixin {
+ public:
+  enum { kEmbedderType, kSlot, kInternalFieldCount };
+  template <typename T>
+  static T* Unwrap(v8::Local<v8::Object> obj) {
+    DCHECK_GE(obj->InternalFieldCount(), T::kInternalFieldCount);
+    T* ptr = static_cast<T*>(obj->GetAlignedPointerFromInternalField(T::kSlot));
+    return ptr;
+  }
+};
+
+#define CPPGC_MIXIN_METHODS()                                                  \
+  v8::Local<v8::Object> object() const {                                       \
+    return traced_reference_.Get(env_->isolate());                             \
+  }                                                                            \
+  Environment* env() const { return env_; }
+
+#define TRACE_CPPGC_OBJECT(visitor) visitor->Trace(traced_reference_);
+
+#define INITIALIZE_CPPGC_OBJECT(env, obj, ptr)                                 \
+  env_ = env;                                                                  \
+  traced_reference_ = v8::TracedReference<v8::Object>(env->isolate(), obj);    \
+  SetCppgcReference(env->isolate(), obj, ptr);
+
+#define DEFAULT_CPPGC_TRACE()                                                  \
+  void Trace(cppgc::Visitor* visitor) const { TRACE_CPPGC_OBJECT(visitor) }
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_BASE_OBJECT_H_

src/util.h

@@ -969,6 +969,30 @@ void SetConstructorFunction(v8::Isolate* isolate,
                             SetConstructorFunctionFlag flag =
                                 SetConstructorFunctionFlag::SET_CLASS_NAME);
 
+#define GET_OR_SET_CONSTRUCTOR_TEMPLATE(tmpl, isolate_data, id, name)          \
+  do {                                                                         \
+    v8::Isolate* isolate = isolate_data->isolate();                            \
+    tmpl = isolate_data->id##_constructor_template();                          \
+    if (tmpl.IsEmpty()) {                                                      \
+      tmpl = v8::FunctionTemplate::New(isolate, New);                          \
+      tmpl->InstanceTemplate()->SetInternalFieldCount(kInternalFieldCount);    \
+      tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, #name));               \
+      isolate_data->set_##id##_constructor_template(tmpl);                     \
+    }                                                                          \
+  } while (0);
+
+#define CONSTRUCTOR_TEMPLATE_GENERATOR(id, name)                               \
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(               \
+      IsolateData* isolate_data) {                                             \
+    v8::Local<v8::FunctionTemplate> tmpl;                                      \
+    GET_OR_SET_CONSTRUCTOR_TEMPLATE(tmpl, isolate_data, id, name);             \
+    return tmpl;                                                               \
+  }
+
+#define DECL_CONSTRUCTOR_TEMPLATE_GENERATOR()                                  \
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(               \
+      IsolateData* isolate_data);
+
 // Like RAIIIsolate, except doesn't enter the isolate while it's in scope.
 class RAIIIsolateWithoutEntering {
  public: