feat(gobject, closure): record created Closure to be traced by cppgc

Replace a Persistent in Closure with a TracedReference. Then, keep track
of created Closure in GObjectWrapper. When GObjectWrapper is traced by
cppgc, trace those reference to tell cppgc they're still alive.

By not creating a Persistent, we prevent a reference loop where the
Persistent holds function, holds JS wrapper, holds GObject, holds
Persistent. When TracedReference, evetually the whole loop will not be
traced by cppgc, allowing the whole loop to be dropped.

This approach is inspired by PyGObject.

Author: peat-psuwit

src/closure.cc

@@ -15,13 +15,13 @@ using v8::Isolate;
 using v8::Local;
 using v8::Object;
 using v8::Value;
-using Nan::Persistent;
 
 namespace GNodeJS {
 
 GClosure *Closure::New (Local<Function> function, GICallableInfo* info, guint signalId) {
     Closure *closure = (Closure *) g_closure_new_simple (sizeof (*closure), GUINT_TO_POINTER(signalId));
-    closure->persistent.Reset(function);
+    closure->isolate = function->GetIsolate();
+    closure->functionRef.Reset(closure->isolate, function);
     if (info) {
         closure->info = g_base_info_ref(info);
     } else {
@@ -34,11 +34,12 @@ GClosure *Closure::New (Local<Function> function, GICallableInfo* info, guint si
 }
 
 void Closure::Execute(GICallableInfo *info, guint signal_id,
-                      const Nan::Persistent<v8::Function> &persFn,
+                      v8::Isolate *isolate,
+                      const v8::TracedReference<v8::Function> &fnRef,
                       GValue *g_return_value, guint n_param_values,
                       const GValue *param_values) {
     Nan::HandleScope scope;
-    auto func = Nan::New<Function>(persFn);
+    auto func = fnRef.Get(isolate);
 
     GSignalQuery signal_query = { 0, };
 
@@ -139,11 +140,25 @@ void Closure::Marshal(GClosure     *base,
 
     if (env->IsSameThread()) {
         /* Case 1: same thread */
-        Closure::Execute(closure->info, signal_id, closure->persistent, g_return_value, n_param_values, param_values);
+        Closure::Execute(
+            closure->info,
+            signal_id,
+            closure->isolate,
+            closure->functionRef,
+            g_return_value,
+            n_param_values,
+            param_values);
     } else {
         /* Case 2: different thread */
         env->Call([&]() {
-            Closure::Execute(closure->info, signal_id, closure->persistent, g_return_value, n_param_values, param_values);
+            Closure::Execute(
+                closure->info,
+                signal_id,
+                closure->isolate,
+                closure->functionRef,
+                g_return_value,
+                n_param_values,
+                param_values);
         });
     }
 }

src/closure.h

@@ -16,11 +16,12 @@ namespace GNodeJS {
 
 struct Closure {
     GClosure base;
-    Nan::Persistent<v8::Function> persistent;
+    v8::Isolate *isolate;
+    v8::TracedReference<v8::Function> functionRef;
     GICallableInfo* info;
 
     ~Closure() {
-        persistent.Reset();
+        functionRef.Reset();
         if (info) g_base_info_unref (info);
     }
 
@@ -29,7 +30,8 @@ struct Closure {
                          guint signalId);
 
     static void Execute(GICallableInfo *info, guint signal_id,
-                        const Nan::Persistent<v8::Function> &persFn,
+                        v8::Isolate *isolate,
+                        const v8::TracedReference<v8::Function> &persFn,
                         GValue *g_return_value, guint n_param_values,
                         const GValue *param_values);
 

src/gobject.cc

@@ -1,5 +1,7 @@
 
 #include <string.h>
+#include <algorithm>
+#include <mutex>
 
 #include "cppgc/allocation.h"
 #include "cppgc/garbage-collected.h"
@@ -70,6 +72,11 @@ class GObjectWrapper : public V8Wrappable {
     }
 
     ~GObjectWrapper() {
+        for (auto closure : watchedClosures) {
+            g_closure_remove_invalidate_notifier(
+                closure, this, &closureInvalidated);
+        }
+
         g_object_remove_toggle_ref (gobject, &ToggleNotify, NULL);
     }
 
@@ -79,14 +86,40 @@ class GObjectWrapper : public V8Wrappable {
     }
 
     void Trace(cppgc::Visitor* visitor) const override {
-        // TODO
+        std::lock_guard l(mutex);
+
+        for (auto closure : watchedClosures) {
+            visitor->Trace(reinterpret_cast<Closure *>(closure)->functionRef);
+        }
     }
 
     GObject * getGObject() {
         return gobject;
     }
+
+    void watchClosure(GClosure * closure) {
+        std::lock_guard l(mutex);
+
+        watchedClosures.push_back(closure);
+        g_closure_add_invalidate_notifier(closure, this, &closureInvalidated);
+    }
+
+    static void closureInvalidated(gpointer data, GClosure * closure) {
+        GObjectWrapper * self = static_cast<GObjectWrapper *>(data);
+        std::lock_guard l(self->mutex);
+
+        // https://stackoverflow.com/a/3385251
+        self->watchedClosures.erase(std::remove(
+            self->watchedClosures.begin(),
+            self->watchedClosures.end(),
+            closure
+        ), self->watchedClosures.end());
+    }
 private:
     GObject * gobject;
+
+    mutable std::mutex mutex;
+    std::vector<GClosure *> watchedClosures;
 };
 
 // Our base template for all GObjects
@@ -399,10 +432,15 @@ static void DestroyVFuncs(GType gtype) {
     g_type_set_qdata (gtype, GNodeJS::vfuncs_quark(), NULL);
 }
 
+// FIXME: reorganize so that we don't have this out-of-place declaration.
+// We probably want to declare GObjectWrapper class in gobject.h now.
+GObjectWrapper * GObjectCppWrapperFromWrapper(Local<Value> value);
+
 NAN_METHOD(SignalConnect) {
     bool after = false;
 
-    GObject *gobject = GObjectFromWrapper (info.This ());
+    GObjectWrapper *cppWrapper = GObjectCppWrapperFromWrapper(info.This ());
+    GObject *gobject = cppWrapper->getGObject();
 
     if (!gobject) {
         Nan::ThrowTypeError("Object is not a GObject");
@@ -448,6 +486,7 @@ NAN_METHOD(SignalConnect) {
     }
 
     gclosure = Closure::New (callback, signal_info, signalId);
+    cppWrapper->watchClosure(gclosure);
     handler_id = g_signal_connect_closure (gobject, signalName, gclosure, after);
 
     info.GetReturnValue().Set((double)handler_id);
@@ -737,7 +776,7 @@ Local<Value> WrapperFromGObject(GObject *gobject) {
     return obj;
 }
 
-GObject * GObjectFromWrapper(Local<Value> value) {
+GObjectWrapper * GObjectCppWrapperFromWrapper(Local<Value> value) {
     if (!ValueHasInternalField(value))
         return nullptr;
 
@@ -755,7 +794,11 @@ GObject * GObjectFromWrapper(Local<Value> value) {
             descriptor.wrappable_instance_index));
 #endif
 
-    return cppWrapper->getGObject();
+    return cppWrapper;
+}
+
+GObject * GObjectFromWrapper(Local<Value> value) {
+    return GObjectCppWrapperFromWrapper(value)->getGObject();
 }
 
 MaybeLocal<Value> GetGObjectProperty(GObject * gobject, const char *prop_name) {