node-gtk 2.2.0 → 4.0.0

package/src/boxed.cc

@@ -6,6 +6,7 @@
 #include "debug.h"
 #include "error.h"
 #include "function.h"
+#include "fundamental.h"
 #include "gi.h"
 #include "gobject.h"
 #include "macros.h"
@@ -258,8 +259,8 @@ static void BoxedConstructor(const Nan::FunctionCallbackInfo<Value> &info) {
     box->persistent = new Nan::Persistent<Object>(self);
     box->persistent->SetWeak(box, BoxedDestroyed, Nan::WeakCallbackType::kParameter);
 
-    self->SetAlignedPointerInInternalField (0, boxed);
-    self->SetAlignedPointerInInternalField (1, box);
+    Nan::SetInternalFieldPointer(self, 0, boxed);
+    Nan::SetInternalFieldPointer(self, 1, box);
 
     SET_OBJECT_GTYPE (self, gtype);
 
@@ -414,6 +415,13 @@ Local<Function> GetBoxedFunction(GIBaseInfo *info, GType gtype) {
 Local<Function> MakeBoxedClass(GIBaseInfo *info) {
     GType gtype = g_registered_type_info_get_g_type ((GIRegisteredTypeInfo *) info);
 
+    // GVariant is a StructInfo but a refcounted fundamental (G_TYPE_VARIANT),
+    // not a boxed value: give it the fundamental ref/unref wrapper instead of
+    // the boxed copy/free one. JS still attaches its struct methods to this
+    // class via makeBoxed() (#465).
+    if (gtype == G_TYPE_VARIANT)
+        return MakeVariantClass (info);
+
     if (gtype == G_TYPE_NONE) {
         auto moduleCache = GNodeJS::GetModuleCache();
         auto ns   = UTF8 (g_base_info_get_namespace (info));
@@ -454,7 +462,7 @@ Local<Value> WrapperFromBoxed(GIBaseInfo *info, void *data, ResourceOwnership ow
 void* PointerFromWrapper(Local<Value> value) {
     Local<Object> object = TO_OBJECT (value);
     g_assert(object->InternalFieldCount() > 0);
-    void *boxed = object->GetAlignedPointerFromInternalField(0);
+    void *boxed = Nan::GetInternalFieldPointer(object, 0);
     return boxed;
 }
 
@@ -467,12 +475,12 @@ void DisownBoxed(Local<Value> value) {
     if (object->InternalFieldCount() < 2)
         return;
 
-    Boxed *box = static_cast<Boxed *>(object->GetAlignedPointerFromInternalField(1));
+    Boxed *box = static_cast<Boxed *>(Nan::GetInternalFieldPointer(object, 1));
     if (box != NULL) {
         box->owns_memory = false;
         box->data = NULL;
     }
-    object->SetAlignedPointerInInternalField(0, NULL);
+    Nan::SetInternalFieldPointer(object, 0, NULL);
 }
 
 };

package/src/closure.cc

@@ -3,6 +3,7 @@
 
 #include "closure.h"
 #include "error.h"
+#include "gobject.h"
 #include "macros.h"
 #include "loop.h"
 #include "type.h"
@@ -54,9 +55,9 @@ static void LoadGIArgumentFromPointer (GITypeInfo *type_info, GIArgument *arg) {
     }
 }
 
-GClosure *Closure::New (Local<Function> function, GICallableInfo* info, guint signalId) {
+GClosure *Closure::New (guint handlerIndex, GICallableInfo* info, guint signalId) {
     Closure *closure = (Closure *) g_closure_new_simple (sizeof (*closure), GUINT_TO_POINTER(signalId));
-    closure->persistent.Reset(function);
+    closure->handlerIndex = handlerIndex;
     if (info) {
         closure->info = g_base_info_ref(info);
     } else {
@@ -69,11 +70,18 @@ GClosure *Closure::New (Local<Function> function, GICallableInfo* info, guint si
 }
 
 void Closure::Execute(GICallableInfo *info, guint signal_id,
-                      const Nan::Persistent<v8::Function> &persFn,
+                      GObject *instance, guint handlerIndex,
                       GValue *g_return_value, guint n_param_values,
                       const GValue *param_values) {
     Nan::HandleScope scope;
-    auto func = Nan::New<Function>(persFn);
+
+    /* The handler lives in a JS array on the instance's wrapper (#375). If the
+     * wrapper has been collected (the object was dropped from JS) there is
+     * nothing to call. */
+    Local<Value> handlerValue = GetSignalHandler(instance, handlerIndex);
+    if (handlerValue.IsEmpty() || !handlerValue->IsFunction())
+        return;
+    auto func = handlerValue.As<Function>();
 
     GSignalQuery signal_query = { 0, };
 
@@ -242,16 +250,21 @@ void Closure::Marshal(GClosure     *base,
 
     auto closure = (Closure *) base;
     auto signal_id = GPOINTER_TO_UINT(marshal_data);
+    auto handlerIndex = closure->handlerIndex;
+
+    /* param_values[0] is always the instance the signal was emitted on, which
+     * is the object whose wrapper holds this handler (#375). */
+    GObject *instance = (GObject *) g_value_get_object(&param_values[0]);
 
     AsyncCallEnvironment* env = reinterpret_cast<AsyncCallEnvironment *>(AsyncCallEnvironment::asyncHandle.data);
 
     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, instance, handlerIndex, 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, instance, handlerIndex, g_return_value, n_param_values, param_values);
         });
     }
 }

package/src/closure.h

@@ -16,20 +16,24 @@ namespace GNodeJS {
 
 struct Closure {
     GClosure base;
-    Nan::Persistent<v8::Function> persistent;
+    /* The handler function is NOT held here. It lives in a JS array on the
+     * wrapper object (reachable only through the wrapper), and we keep just its
+     * index. This breaks the wrapper <-> handler reference loop that a strong
+     * Nan::Persistent used to create and leak (#375); see
+     * doc/signal-handler-gc.md. */
+    guint handlerIndex;
     GICallableInfo* info;
 
     ~Closure() {
-        persistent.Reset();
         if (info) g_base_info_unref (info);
     }
 
-    static GClosure *New(Local<Function> function,
+    static GClosure *New(guint handlerIndex,
                          GICallableInfo* info,
                          guint signalId);
 
     static void Execute(GICallableInfo *info, guint signal_id,
-                        const Nan::Persistent<v8::Function> &persFn,
+                        GObject *instance, guint handlerIndex,
                         GValue *g_return_value, guint n_param_values,
                         const GValue *param_values);
 

package/src/function.cc

@@ -5,6 +5,7 @@
 #include "callback.h"
 #include "debug.h"
 #include "error.h"
+#include "fundamental.h"
 #include "function.h"
 #include "gobject.h"
 #include "macros.h"
@@ -134,6 +135,43 @@ bool IsDestroyNotify (GIBaseInfo *info) {
         && strcmp(g_base_info_get_namespace(info), "GLib") == 0;
 }
 
+/*
+ * A transfer-full GObject return value hands node-gtk an *owning* reference. The
+ * JS wrapper only needs node-gtk's toggle reference, so that extra reference has
+ * to be released — otherwise the refcount never falls back to 1, ToggleNotify
+ * never flips the V8 handle to weak, and the GObject (plus its wrapper) leaks for
+ * the lifetime of the process. This is the leak reported in #446: objects from
+ * GI function returns (`Type.new()`, transfer-full getters, …) were never GC'd,
+ * while `new Type()` — which drops its construction ref in GObjectConstructor —
+ * was. It is the return-value counterpart of OUT GObject args, which
+ * FreeGIArgument already balances; the return value is otherwise never freed on
+ * the success path. (The IN counterpart is RefObjectForTransferFullIn, #439.)
+ *
+ * Must be sampled *before* the value is wrapped: associating the wrapper sinks a
+ * floating reference (consuming it), after which a floating incoming ref (nothing
+ * extra to drop) is indistinguishable from a real owned one. G_IS_OBJECT excludes
+ * GParamSpec (wrapped via ParamSpec::FromGParamSpec) and boxed/fundamental
+ * interface types.
+ */
+static bool OwnsExtraGObjectReturnRef(GITypeInfo *return_type, GITransfer transfer, gpointer ptr) {
+    if (transfer != GI_TRANSFER_EVERYTHING || ptr == NULL)
+        return false;
+
+    if (g_type_info_get_tag(return_type) != GI_TYPE_TAG_INTERFACE)
+        return false;
+
+    GIBaseInfo *iface = g_type_info_get_interface(return_type);
+    GIInfoType  itype = g_base_info_get_type(iface);
+
+    bool result =
+        (itype == GI_INFO_TYPE_OBJECT || itype == GI_INFO_TYPE_INTERFACE)
+        && G_IS_OBJECT(ptr)
+        && !g_object_is_floating(ptr);
+
+    g_base_info_unref(iface);
+    return result;
+}
+
 
 /**
  * The constructor just stores the GIBaseInfo ref. The rest of the
@@ -485,11 +523,14 @@ Local<Value> FunctionCall (
                 // Boxed: hand it a copy so the JS wrapper's own memory isn't
                 // double-freed when finalized (#409). GObject: add the reference
                 // the callee will own, so it isn't finalized out from under the
-                // callee once the wrapper is GC'd (#439).
+                // callee once the wrapper is GC'd (#439). Fundamental (e.g.
+                // GskRenderNode): add the reference the callee will own (#468).
                 else if (direction == GI_DIRECTION_IN
                         && g_arg_info_get_ownership_transfer(&arg_info) == GI_TRANSFER_EVERYTHING) {
                     CopyBoxedForTransferFullIn(&type_info, &callable_arg_values[i], param.length);
                     RefObjectForTransferFullIn(&type_info, &callable_arg_values[i]);
+                    RefFundamentalForTransferFullIn(&type_info, &callable_arg_values[i]);
+                    RefVariantForTransferFullIn(&type_info, &callable_arg_values[i]);
                 }
             }
 
@@ -549,6 +590,13 @@ Local<Value> FunctionCall (
 
     } else if (!use_return_value) {
 
+        // A transfer-full GObject return hands us an extra owning reference on
+        // top of the wrapper's toggle ref; drop it once wrapped so the object
+        // isn't pinned alive forever (#446). Sampled now, before wrapping sinks
+        // any floating reference.
+        bool release_return_ref =
+            OwnsExtraGObjectReturnRef(&return_type, return_transfer, return_value_stack.v_pointer);
+
         // Value transferred to jsReturnValue
         jsReturnValue = func->JsReturnValue (
                 info.This(),
@@ -556,6 +604,9 @@ Local<Value> FunctionCall (
                 &return_value_stack,
                 callable_arg_values,
                 return_transfer);
+
+        if (release_return_ref)
+            g_object_unref (return_value_stack.v_pointer);
     } else {
 
         // Value returned in return_value
@@ -661,7 +712,8 @@ Local<Value> FunctionInfo::JsReturnValue (
         ADD_RETURN (isReturningSelf ? self :
             GIArgumentToV8 (
                 return_type, return_value, length,
-                return_transfer == GI_TRANSFER_EVERYTHING ? kTransfer : kNone))
+                return_transfer == GI_TRANSFER_EVERYTHING ? kTransfer : kNone,
+                g_callable_info_may_return_null (info)))
     }
 
     for (int i = 0; i < n_callable_args; i++) {
@@ -695,20 +747,22 @@ Local<Value> FunctionInfo::JsReturnValue (
                         &callable_arg_values[length_i],
                         IsDirectionOut(length_direction));
 
-                Local<Value> result = ArrayToV8(&arg_type, *(void**)arg_value.v_pointer, param.length);
+                bool may_be_null = g_arg_info_may_be_null(&arg_info);
+                Local<Value> result = ArrayToV8(&arg_type, *(void**)arg_value.v_pointer, param.length, may_be_null);
 
                 ADD_RETURN (result)
 
             } else if (param.type == ParameterType::kNORMAL) {
                 GITransfer transfer = g_arg_info_get_ownership_transfer(&arg_info);
                 ResourceOwnership ownership = transfer == GI_TRANSFER_EVERYTHING ? kTransfer : kNone;
+                bool may_be_null = g_arg_info_may_be_null(&arg_info);
 
                 if (IsPointerType(&arg_type) && g_arg_info_is_caller_allocates(&arg_info)) {
                     void *pointer = &arg_value.v_pointer;
-                    ADD_RETURN (GIArgumentToV8(&arg_type, (GIArgument*) pointer, -1, ownership))
+                    ADD_RETURN (GIArgumentToV8(&arg_type, (GIArgument*) pointer, -1, ownership, may_be_null))
                 }
                 else {
-                    ADD_RETURN (GIArgumentToV8(&arg_type, (GIArgument*) arg_value.v_pointer, -1, ownership))
+                    ADD_RETURN (GIArgumentToV8(&arg_type, (GIArgument*) arg_value.v_pointer, -1, ownership, may_be_null))
                 }
             }
         }