node-gtk 1.0.0 → 2.1.0

package/src/function.cc

@@ -55,7 +55,9 @@ static void* AllocateArgument (GIBaseInfo *arg_info) {
 
     GIBaseInfo* base_info = g_type_info_get_interface (&arg_type);
     size_t size = Boxed::GetSize (base_info);
-    void* pointer = g_malloc0(size);
+    GType gtype = g_registered_type_info_get_g_type (base_info);
+    // Match g_boxed_free's allocator for registered boxed types (#290, #213).
+    void* pointer = AllocateBoxed(gtype, size);
 
     g_base_info_unref(base_info);
     return pointer;
@@ -67,6 +69,35 @@ static bool IsMethod (GIBaseInfo *info) {
             (flags & GI_FUNCTION_IS_CONSTRUCTOR) == 0);
 }
 
+static bool EndsWith (const char *str, const char *suffix) {
+    size_t str_len = strlen (str);
+    size_t suffix_len = strlen (suffix);
+    return str_len >= suffix_len && strcmp (str + str_len - suffix_len, suffix) == 0;
+}
+
+/* True for an instance method that deallocates the instance itself — a *_free
+ * or *_unref on a boxed/struct/union. node-gtk's wrapper owns the memory and
+ * frees it on GC, so after such a call the wrapper must disown it or GC will
+ * double-free (#429). Restricted to boxed-like containers: GObject lifetime is
+ * handled separately, and gtk_widget_destroy() etc. don't free the wrapper. */
+static bool FreesInstance (GIFunctionInfo *info) {
+    if (!IsMethod (info))
+        return false;
+
+    const char *symbol = g_function_info_get_symbol (info);
+    if (symbol == NULL || !(EndsWith (symbol, "_free") || EndsWith (symbol, "_unref")))
+        return false;
+
+    GIBaseInfo *container = g_base_info_get_container (info);
+    if (container == NULL)
+        return false;
+
+    GIInfoType type = g_base_info_get_type (container);
+    return type == GI_INFO_TYPE_STRUCT
+        || type == GI_INFO_TYPE_UNION
+        || type == GI_INFO_TYPE_BOXED;
+}
+
 static bool ShouldSkipReturn(GIBaseInfo *info, GITypeInfo *return_type) {
     return g_type_info_get_tag(return_type) == GI_TYPE_TAG_VOID
         || g_callable_info_skip_return(info) == TRUE;
@@ -134,6 +165,7 @@ bool FunctionInfo::Init() {
 
     is_method = IsMethod(info);
     can_throw = g_callable_info_can_throw_gerror (info);
+    frees_instance = FreesInstance(info);
 
     n_callable_args = g_callable_info_get_n_args (info);
     n_total_args = n_callable_args;
@@ -208,14 +240,14 @@ bool FunctionInfo::Init() {
                     if (closure_i >= 0 && closure_i < n_callable_args)
                         call_parameters[closure_i].type = ParameterType::kSKIP;
 
-                    if (destroy_i < i) {
+                    if (destroy_i >= 0 && destroy_i < i) {
                         if (IsDirectionIn(call_parameters[destroy_i].direction))
                             n_in_args--;
                         if (IsDirectionOut(call_parameters[destroy_i].direction))
                             n_out_args--;
                     }
 
-                    if (closure_i < i) {
+                    if (closure_i >= 0 && closure_i < i) {
                         if (IsDirectionIn(call_parameters[closure_i].direction))
                             n_in_args--;
                         if (IsDirectionOut(call_parameters[closure_i].direction))
@@ -388,16 +420,16 @@ Local<Value> FunctionCall (
         }
         else if (param.type == ParameterType::kCALLBACK) {
             Callback *callback;
-            ffi_closure *closure;
+            gpointer callable; /* executable trampoline address (see Callback) */
 
             if (info[in_arg]->IsNullOrUndefined()) {
-                closure  = nullptr;
+                callable = nullptr;
                 callback = nullptr;
             } else {
                 GICallableInfo *callback_info = g_type_info_get_interface (&type_info);
                 GIScopeType scope_type = g_arg_info_get_scope(&arg_info);
                 callback = new Callback(info[in_arg].As<Function>(), callback_info, scope_type);
-                closure = callback->closure;
+                callable = callback->native_address;
                 g_base_info_unref (callback_info);
             }
 
@@ -414,7 +446,7 @@ Local<Value> FunctionCall (
                 callable_arg_values[closure_i].v_pointer = callback;
             }
 
-            callable_arg_values[i].v_pointer = closure;
+            callable_arg_values[i].v_pointer = callable;
             func->call_parameters[i].data.v_pointer = callback;
         }
 
@@ -440,6 +472,25 @@ Local<Value> FunctionCall (
                     param.data.v_pointer = callable_arg_values[i].v_pointer;
                     callable_arg_values[i].v_pointer = &param.data;
                 }
+                // For a transfer-container IN GList/GSList/GHashTable the callee
+                // frees the container; snapshot the (caller-owned) element
+                // pointers now so they can be freed after the call (#399).
+                else if (IsTransferContainerInList(&type_info,
+                            g_arg_info_get_ownership_transfer(&arg_info), direction)) {
+                    param.data = {};
+                    param.data.v_pointer = CaptureTransferContainerElements(
+                            &type_info, callable_arg_values[i].v_pointer);
+                }
+                // For a transfer-full IN argument the callee takes ownership.
+                // 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).
+                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]);
+                }
             }
 
             in_arg++;
@@ -538,6 +589,11 @@ Local<Value> FunctionCall (
                 delete callback;
             }
         }
+        else if (IsTransferContainerInList (&arg_type, transfer, direction)) {
+            // The callee already freed the container structure; free only the
+            // captured (caller-owned) elements, never the freed container (#399).
+            FreeTransferContainerElements (&arg_type, param.data.v_pointer);
+        }
         else {
             if (direction == GI_DIRECTION_INOUT || (direction == GI_DIRECTION_OUT && !g_arg_info_is_caller_allocates (&arg_info)))
                 FreeGIArgument (&arg_type, (GIArgument*)arg_value.v_pointer, transfer, direction);
@@ -546,6 +602,11 @@ Local<Value> FunctionCall (
         }
     }
 
+    // If this method freed the instance, drop node-gtk's ownership of it so the
+    // GC finalizer won't free it a second time (#429).
+    if (func->frees_instance && !didThrow)
+        DisownBoxed (info.This());
+
     #ifndef __linux__
         delete[] total_arg_values;
     #endif

package/src/function.h

@@ -33,6 +33,7 @@ struct FunctionInfo {
 
     bool is_method;
     bool can_throw;
+    bool frees_instance; /* a *_free/*_unref method that deallocates the instance (#429) */
 
     int n_callable_args;
     int n_total_args;

package/src/gi.cc

@@ -208,6 +208,49 @@ NAN_METHOD(ObjectPropertySetter) {
         RETURN(success.ToLocalChecked());
 }
 
+// All members of a C union live at offset 0. Some GLib versions (the
+// regression fixed in 2.86.1 — glib#3745) emit a bogus 0xffff offset for union
+// field members in the compiled typelib, so g_field_info_get_field /
+// g_field_info_set_field would read/write far out of bounds and crash. Detect
+// union fields so they can be accessed directly at offset 0 instead (#376).
+static bool FieldIsInUnion (GIFieldInfo *field) {
+    GIBaseInfo *container = g_base_info_get_container (field);
+    return container != NULL
+        && g_base_info_get_type (container) == GI_INFO_TYPE_UNION;
+}
+
+// Whether a field type is a simple (non-pointer) C value that can be read or
+// written by copying its bytes — mirrors what g_field_info_get/set_field
+// accept. Pointer-backed types (strings, nested structs, arrays, ...) return
+// false and are rejected, as before.
+static bool IsSimpleFieldType (GITypeInfo *type_info) {
+    switch (g_type_info_get_tag (type_info)) {
+        case GI_TYPE_TAG_BOOLEAN:
+        case GI_TYPE_TAG_INT8:
+        case GI_TYPE_TAG_UINT8:
+        case GI_TYPE_TAG_INT16:
+        case GI_TYPE_TAG_UINT16:
+        case GI_TYPE_TAG_INT32:
+        case GI_TYPE_TAG_UINT32:
+        case GI_TYPE_TAG_INT64:
+        case GI_TYPE_TAG_UINT64:
+        case GI_TYPE_TAG_FLOAT:
+        case GI_TYPE_TAG_DOUBLE:
+        case GI_TYPE_TAG_UNICHAR:
+        case GI_TYPE_TAG_GTYPE:
+            return true;
+        case GI_TYPE_TAG_INTERFACE: {
+            GIBaseInfo *iface = g_type_info_get_interface (type_info);
+            GIInfoType  itype = g_base_info_get_type (iface);
+            bool simple = (itype == GI_INFO_TYPE_ENUM || itype == GI_INFO_TYPE_FLAGS);
+            g_base_info_unref (iface);
+            return simple;
+        }
+        default:
+            return false;
+    }
+}
+
 NAN_METHOD(StructFieldSetter) {
     Local<Object> boxedWrapper = info[0].As<Object>();
     Local<Object> fieldInfo    = info[1].As<Object>();
@@ -231,6 +274,17 @@ NAN_METHOD(StructFieldSetter) {
 
         RETURN (Nan::Undefined());
 
+    } else if (FieldIsInUnion(field)) {
+
+        // Union members are at offset 0; write directly to avoid the bogus
+        // introspected offset (glib#3745, #376).
+        if (IsSimpleFieldType(field_type)) {
+            memcpy(boxed, &arg, GNodeJS::GetTypeSize(field_type));
+        } else {
+            Nan::ThrowError("Unable to set field (complex types not allowed)");
+            RETURN (Nan::Undefined());
+        }
+
     } else {
 
         if (g_field_info_set_field(field, boxed, &arg) == FALSE) {
@@ -286,6 +340,19 @@ NAN_METHOD(StructFieldGetter) {
     GNodeJS::ResourceOwnership ownership = GNodeJS::kCopy;
     BaseInfo typeInfo = g_field_info_get_type(*fieldInfo);
 
+    if (FieldIsInUnion(*fieldInfo)) {
+        // Union members are at offset 0; read directly to avoid the bogus
+        // introspected offset (glib#3745, #376).
+        if (!IsSimpleFieldType(*typeInfo)) {
+            Nan::ThrowError("Converting non-primitive fields is not allowed");
+            return;
+        }
+        memset(&value, 0, sizeof(value));
+        memcpy(&value, boxed, GNodeJS::GetTypeSize(*typeInfo));
+        RETURN(GNodeJS::GIArgumentToV8(*typeInfo, &value, -1, ownership));
+        return;
+    }
+
     if (!g_field_info_get_field(*fieldInfo, boxed, &value)) {
         /* If g_field_info_get_field() failed, this is a non-primitive type */
 
@@ -313,6 +380,10 @@ NAN_METHOD(StartLoop) {
     GNodeJS::StartLoop ();
 }
 
+NAN_METHOD(IsRunningMicrotasks) {
+    info.GetReturnValue().Set(Nan::New<Boolean>(GNodeJS::IsRunningMicrotasks ()));
+}
+
 NAN_METHOD(GetBaseClass) {
     auto tpl = GNodeJS::GetBaseClassTemplate ();
     auto fn = Nan::GetFunction (tpl).ToLocalChecked();
@@ -358,6 +429,7 @@ void InitModule(Local<Object> exports, Local<Value> module, void *priv) {
     Nan::Export(exports, "ObjectPropertyGetter", ObjectPropertyGetter);
     Nan::Export(exports, "ObjectPropertySetter", ObjectPropertySetter);
     Nan::Export(exports, "StartLoop",            StartLoop);
+    Nan::Export(exports, "IsRunningMicrotasks",  IsRunningMicrotasks);
     Nan::Export(exports, "GetLoopStack",         GetLoopStack);
     Nan::Export(exports, "RegisterClass",        RegisterClass);
     Nan::Export(exports, "RegisterVFunc",        RegisterVFunc);

package/src/gobject.cc

@@ -34,7 +34,6 @@ namespace GNodeJS {
 static Nan::Persistent<FunctionTemplate> baseTemplate;
 
 
-static void GObjectDestroyed(const Nan::WeakCallbackInfo<GObject> &data);
 static MaybeLocal<FunctionTemplate> GetClassTemplate(GType gtype);
 static MaybeLocal<Function>         GetClass(GType gtype);
 static void StoreVFunc(GType gtype, Callback *callback);
@@ -59,12 +58,18 @@ static GObject* CreateGObjectFromObject(GType gtype, Local<Value> object) {
 
     for (int i = 0; i < n_properties; i++) {
         Local<String> name = TO_STRING (Nan::Get(properties, i).ToLocalChecked());
-        const char *name_string = g_strdup (*Nan::Utf8String(name));
+        // Accept camelCase property names (e.g. iconName) in addition to
+        // dashed/underscored ones; GObject canonicalizes '_' to '-' but not
+        // camelCase, so convert here (#320). The original spelling is kept so
+        // an unknown name is reported as the user wrote it.
+        Nan::Utf8String name_original (name);
+        char *name_string = Util::ToDashed (*name_original);
         Local<Value> value = Nan::Get(property_hash, name).ToLocalChecked();
 
         auto value_spec = g_object_class_find_property (G_OBJECT_CLASS (klass), name_string);
         if (value_spec == NULL) {
-            Throw::InvalidPropertyName(name_string);
+            Throw::InvalidPropertyName(*name_original);
+            g_free(name_string);
             goto out;
         }
 
@@ -94,21 +99,66 @@ out:
     return gobject;
 }
 
+struct GObjectWrapper;
+static void GObjectDestroyedFirstPass(const v8::WeakCallbackInfo<GObjectWrapper> &data);
+static void GObjectDestroyedSecondPass(const v8::WeakCallbackInfo<GObjectWrapper> &data);
+static void GObjectFinalized(gpointer data, GObject *where_the_object_was);
+
+struct GObjectWrapper {
+    Nan::Persistent<Object> persistent;
+    GObject *gobject;
+    /* Set to true the moment SetWeak is called. Between that point and the
+     * destroy callback actually running, the V8 handle is weak (and, once GC
+     * reclaims it, dead). If ToggleNotify fires in that window (because native
+     * code adjusts the refcount), touching the persistent crashes. Guard every
+     * persistent access with this flag. */
+    bool dying = false;
+    /* Set in the first-pass weak callback, i.e. the instant GC reclaims the
+     * wrapper, before any JS/GTK code resumes. While this is true the
+     * persistent is dead but the qdata still points here until the second-pass
+     * callback runs; WrapperFromGObject must build a fresh wrapper rather than
+     * resurrect this one. */
+    bool collected = false;
+};
+
 static void ToggleNotify(gpointer user_data, GObject *gobject, gboolean toggle_down) {
     void *data = g_object_get_qdata (gobject, GNodeJS::object_quark());
 
     g_assert (data != NULL);
 
-    auto *persistent = (Nan::Persistent<Object> *) data;
+    auto *wrapper = (GObjectWrapper *) data;
+
+    /* The V8 handle has already been reclaimed by GC (collected) — it is dead
+     * and can be made neither weak nor strong. If the object is marshalled
+     * again, WrapperFromGObject builds a fresh wrapper. */
+    if (wrapper->collected)
+        return;
 
     if (toggle_down) {
-        /* We're dropping from 2 refs to 1 ref. We are the last holder. Make
-         * sure that that our weak ref is installed. */
-        persistent->SetWeak (gobject, GObjectDestroyed, v8::WeakCallbackType::kParameter);
+        /* We're dropping from 2 refs to 1 ref: we are the last holder, so the
+         * wrapper may be collected. Install the weak ref (unless it already is). */
+        if (wrapper->dying)
+            return;
+        wrapper->dying = true;
+        /* Two-pass weak callback: the first pass runs *during* GC (before any
+         * JS/GTK code resumes) and only flips a flag, so WrapperFromGObject can
+         * tell a reclaimed wrapper from a live one and never marshals a dead
+         * handle to JS. All GObject teardown happens in the second pass — a
+         * first-pass callback may not call into GObject. */
+        wrapper->persistent.v8::PersistentBase<Object>::SetWeak (
+            wrapper, GObjectDestroyedFirstPass, v8::WeakCallbackType::kParameter);
     } else {
-        /* We're going from 1 ref to 2 refs. We can't let our wrapper be
-         * collected, so make sure that our reference is persistent */
-        persistent->ClearWeak ();
+        /* We're going from 1 ref to 2 refs: something other than us now holds
+         * the object, so the wrapper must stay alive (strong) until that ref is
+         * dropped again. Reviving here is essential — without it a wrapper that
+         * went weak once (e.g. a freshly constructed object at refcount 1) would
+         * never become strong again when GTK takes ownership, and GC could then
+         * collect a wrapper whose GObject is still in use (notably a subclassed
+         * widget owned by GTK, losing its overridden vfuncs and instance state). */
+        if (!wrapper->dying)
+            return;
+        wrapper->dying = false;
+        wrapper->persistent.ClearWeak ();
     }
 }
 
@@ -117,8 +167,10 @@ static void AssociateGObject(Local<Object> object, GObject *gobject, GType gtype
 
     SET_OBJECT_GTYPE(object, gtype);
 
-    auto *persistent = new Nan::Persistent<Object>(object);
-    g_object_set_qdata (gobject, GNodeJS::object_quark(), persistent);
+    auto *wrapper = new GObjectWrapper();
+    wrapper->gobject = gobject;
+    wrapper->persistent.Reset(object);
+    g_object_set_qdata (gobject, GNodeJS::object_quark(), wrapper);
 
     // Because we can't sink floating ref and add toggle ref at the same time,
     // first sink the floating ref, add the toggle ref, and then release the
@@ -126,6 +178,18 @@ static void AssociateGObject(Local<Object> object, GObject *gobject, GType gtype
     g_object_ref_sink (gobject);
     g_object_add_toggle_ref (gobject, ToggleNotify, NULL);
     g_object_unref (gobject);
+
+    // The toggle ref above is supposed to keep the GObject alive for as long as
+    // the wrapper exists. A weak ref guards against the case where it doesn't —
+    // e.g. a JS-subclassed instance whose refcount is driven to 0 from the GTK
+    // side while we still hold the toggle ref: GObjectFinalized then clears the
+    // dangling pointer so the destroy callbacks never touch freed memory.
+    g_object_weak_ref (gobject, GObjectFinalized, wrapper);
+}
+
+static void GObjectFinalized(gpointer data, GObject *where_the_object_was) {
+    auto *wrapper = (GObjectWrapper *) data;
+    wrapper->gobject = NULL;
 }
 
 static void GObjectConstructor(const FunctionCallbackInfo<Value> &info) {
@@ -177,18 +241,71 @@ static void GObjectConstructor(const FunctionCallbackInfo<Value> &info) {
     }
 }
 
-static void GObjectDestroyed(const Nan::WeakCallbackInfo<GObject> &data) {
-    GObject *gobject = data.GetParameter ();
+static void GObjectDestroyedFirstPass(const v8::WeakCallbackInfo<GObjectWrapper> &data) {
+    GObjectWrapper *wrapper = data.GetParameter ();
+
+    /* This runs *during* GC, where it is not legal to call into V8 (beyond
+     * resetting the handle, which the two-pass contract requires) or into
+     * GObject — the GObject is not safe to touch here, and doing so crashes in
+     * g_type_check_instance_is_fundamentally_a. So only flip a flag and reset
+     * the handle; the real teardown is deferred to the second pass.
+     *
+     * The flag lets WrapperFromGObject distinguish a reclaimed wrapper (whose
+     * persistent is now dead) from a live one during the window before the
+     * second pass nulls the qdata, so it builds a fresh wrapper instead of
+     * handing the dead handle to JS — which crashed on first property access. */
+    wrapper->collected = true;
+    wrapper->persistent.Reset ();
+
+    data.SetSecondPassCallback (GObjectDestroyedSecondPass);
+}
 
-    void *type_data = g_object_get_qdata (gobject, GNodeJS::object_quark());
-    auto *persistent = (Nan::Persistent<Object> *) type_data;
-    delete persistent;
+static gboolean GObjectTeardownIdle(gpointer data) {
+    GObjectWrapper *wrapper = (GObjectWrapper *) data;
+    GObject *gobject = wrapper->gobject;
+
+    /* If the GObject was already finalized out from under us, GObjectFinalized
+     * cleared the pointer; there is nothing left to detach or unref. */
+    if (gobject != NULL) {
+        /* Drop the weak ref first so removing the toggle ref (which may finalize
+         * the object) doesn't re-enter GObjectFinalized. */
+        g_object_weak_unref (gobject, GObjectFinalized, wrapper);
+
+        /* Only detach the qdata if it still points at us — WrapperFromGObject
+         * may have resurrected this GObject with a fresh wrapper while we were
+         * pending, and we must not clobber it. */
+        if (g_object_get_qdata (gobject, GNodeJS::object_quark()) == wrapper)
+            g_object_set_qdata (gobject, GNodeJS::object_quark(), NULL);
+
+        /* Dropping the last toggle ref disposes the object, and GTK's dispose
+         * synchronously emits signals (e.g. ::destroy) into still-connected
+         * node-gtk closures — i.e. it re-enters arbitrary JS. That is only legal
+         * here because we run from a GLib idle on the main loop, not from the GC
+         * second-pass callback that scheduled us (see GObjectDestroyedSecondPass). */
+        g_object_remove_toggle_ref (gobject, &ToggleNotify, NULL);
+    }
 
-    /* We're destroying the wrapper object, so make sure to clear out
-     * the qdata that points back to us. */
-    g_object_set_qdata (gobject, GNodeJS::object_quark(), NULL);
+    delete wrapper;
+    return G_SOURCE_REMOVE;
+}
 
-    g_object_remove_toggle_ref (gobject, &ToggleNotify, NULL);
+static void GObjectDestroyedSecondPass(const v8::WeakCallbackInfo<GObjectWrapper> &data) {
+    GObjectWrapper *wrapper = data.GetParameter ();
+
+    /* Defer the actual teardown to a main-loop idle instead of running it here.
+     * This callback fires from V8's InvokeSecondPassPhantomCallbacks *during* a
+     * garbage collection. Dropping the toggle ref can take the GObject's refcount
+     * to zero, and GTK's dispose then emits signals into node-gtk closures,
+     * re-entering JS (Nan::Call) — which crashes when invoked mid-GC. Running the
+     * teardown from a GLib idle moves the ref drop (and any disposal/signal
+     * emission it triggers) to a point where calling into JS is safe again.
+     *
+     * The GObject stays alive across the window because we still hold the toggle
+     * ref; the wrapper (with its now-reset persistent and collected=true) is kept
+     * until the idle deletes it. WrapperFromGObject already handles a resurrected
+     * GObject during this window by building a fresh wrapper, and the idle's
+     * qdata check above won't clobber it. */
+    g_idle_add (GObjectTeardownIdle, wrapper);
 }
 
 static void GObjectClassDestroyed(const Nan::WeakCallbackInfo<GType> &info) {
@@ -333,8 +450,7 @@ static void StoreVFunc(GType gtype, Callback *callback) {
 static void DestroyVFuncs(GType gtype) {
     /* Destroy vfunc list, if any */
     GSList *list = (GSList *) g_type_get_qdata (gtype, GNodeJS::vfuncs_quark());
-    GSList *item = list;
-    while ((item = g_slist_next (item)) != NULL) {
+    for (GSList *item = list; item != NULL; item = item->next) {
         auto callback = (Callback *) item->data;
         delete callback;
     }
@@ -652,10 +768,15 @@ Local<Value> WrapperFromGObject(GObject *gobject) {
     void *data = g_object_get_qdata (gobject, GNodeJS::object_quark());
 
     if (data) {
-        /* Easy case: we already have an object. */
-        auto *persistent = (Nan::Persistent<Object> *) data;
-        auto obj = New<Object> (*persistent);
-        return obj;
+        auto *wrapper = (GObjectWrapper *) data;
+        /* Reuse the existing wrapper unless GC has already reclaimed it (its
+         * persistent is dead and only awaiting the second-pass teardown). In
+         * that case fall through and build a fresh wrapper; the stale one's
+         * second pass is guarded so it won't clobber the new qdata. */
+        if (!wrapper->collected) {
+            auto obj = New<Object> (wrapper->persistent);
+            return obj;
+        }
     }
 
     GType gtype = G_OBJECT_TYPE(gobject);

package/src/loop.cc

@@ -26,6 +26,8 @@ static Nan::Persistent<Array> loopStack(Nan::New<Array> ());
 struct uv_loop_source {
     GSource source;
     uv_loop_t *loop;
+    gpointer fd_tag;
+    bool fd_polled;
 };
 
 static gboolean loop_source_prepare (GSource *base, int *timeout) {
@@ -45,6 +47,24 @@ static gboolean loop_source_prepare (GSource *base, int *timeout) {
 
     bool loop_alive = uv_loop_alive (source->loop);
 
+    /* Toggle whether GLib polls uv's backend fd. When the loop is dead we must
+     * stop polling it: an *unref'd* but still-active uv handle (e.g. the async
+     * eventfd left signaling by emscripten/WASM runtimes such as web-tree-sitter,
+     * or by worker_threads) keeps the backend epoll fd perpetually readable.
+     * uv_loop_alive() reports the loop dead (unref'd handles don't count), so we
+     * intend to sleep here, but a polled-and-ready fd makes GLib's poll() return
+     * immediately every iteration -> loop_source_dispatch() busy-spins at 100%
+     * CPU, starving GTK. Masking the fd lets GLib actually block until a GTK
+     * source wakes us; we restore polling as soon as the loop is alive again. */
+#if !OS_WINDOWS
+    if (source->fd_tag != NULL && loop_alive != source->fd_polled) {
+        g_source_modify_unix_fd (&source->source, source->fd_tag,
+                                 loop_alive ? (GIOCondition) (G_IO_IN | G_IO_OUT | G_IO_ERR)
+                                            : (GIOCondition) 0);
+        source->fd_polled = loop_alive;
+    }
+#endif
+
     /* If the loop is dead, we can simply sleep forever until a GTK+ source
      * (presumably) wakes us back up again. */
     if (!loop_alive)
@@ -92,13 +112,15 @@ static GSourceFuncs uv_loop_source_funcs = {
 static GSource *loop_source_new (uv_loop_t *loop) {
     struct uv_loop_source *source = (struct uv_loop_source *) g_source_new (&uv_loop_source_funcs, sizeof (*source));
     source->loop = loop;
+    source->fd_tag = NULL;
+    source->fd_polled = true;
 #if OS_WINDOWS
     // FIXME
     // https://github.com/nodejs/node/issues/36015
 #else
-    g_source_add_unix_fd (&source->source,
-                          uv_backend_fd (loop),
-                          (GIOCondition) (G_IO_IN | G_IO_OUT | G_IO_ERR));
+    source->fd_tag = g_source_add_unix_fd (&source->source,
+                                           uv_backend_fd (loop),
+                                           (GIOCondition) (G_IO_IN | G_IO_OUT | G_IO_ERR));
 #endif
     return &source->source;
 }
@@ -145,6 +167,20 @@ void CallMicrotaskHandlers () {
 #endif
 }
 
+bool IsRunningMicrotasks() {
+    /* True while V8 is draining the microtask queue. Under ES modules the
+     * top-level body executes as a microtask, so a synchronous blocking call
+     * (e.g. g_main_loop_run) made from it nests inside this drain. V8 refuses
+     * nested microtask checkpoints, so any Promise/async continuation queued
+     * by user code is stuck until the blocking call returns. Callers use this
+     * to detect that situation and defer the blocking call to a macrotask so
+     * the module's top-level microtask can return and the queue can drain.
+     *
+     * - https://github.com/romgrk/node-gtk/issues/442
+     */
+    return MicrotasksScope::IsRunningMicrotasks(Isolate::GetCurrent());
+}
+
 void StartLoop() {
     GSource *source = loop_source_new (uv_default_loop ());
     g_source_attach (source, NULL);

package/src/loop.h

@@ -12,6 +12,8 @@ namespace GNodeJS {
 
   void StartLoop();
 
+  bool IsRunningMicrotasks();
+
   void QuitLoopStack();
 
   Local<Array> GetLoopStack();

package/src/type.cc

@@ -15,11 +15,12 @@ char *GetInfoName (GIBaseInfo* info) {
 
     char* name = g_strdup (info_name);
 
-    GIBaseInfo *parent;
-    while ((parent = g_base_info_get_container (info)) != NULL) {
+    GIBaseInfo *parent = g_base_info_get_container (info);
+    while (parent != NULL) {
         char *new_name = g_strconcat (g_base_info_get_name(parent), ".", name, NULL);
         g_free (name);
         name = new_name;
+        parent = g_base_info_get_container (parent);
     }
 
     char *new_name = g_strconcat (g_base_info_get_namespace(info), ".", name, NULL);