LCOV - code coverage report
Current view: top level - gi - object.cpp (source / functions) Coverage Total Hit
Test: gjs- Code Coverage Lines: 84.1 % 1539 1295
Test Date: 2024-04-29 05:18:28 Functions: 96.9 % 129 125
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 69.8 % 941 657

             Branch data     Line data    Source code
       1                 :             : /* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
       2                 :             : // SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
       3                 :             : // SPDX-FileCopyrightText: 2008 litl, LLC
       4                 :             : // SPDX-FileCopyrightText: 2018 Philip Chimento <philip.chimento@gmail.com>
       5                 :             : 
       6                 :             : #include <config.h>
       7                 :             : 
       8                 :             : #include <stdint.h>
       9                 :             : #include <string.h>  // for memset, strcmp
      10                 :             : 
      11                 :             : #include <algorithm>  // for find
      12                 :             : #include <functional>  // for mem_fn
      13                 :             : #include <limits>
      14                 :             : #include <string>
      15                 :             : #include <tuple>  // for tie
      16                 :             : #include <unordered_set>
      17                 :             : #include <utility>      // for move
      18                 :             : #include <vector>
      19                 :             : 
      20                 :             : #include <girepository.h>
      21                 :             : #include <glib-object.h>
      22                 :             : #include <glib.h>
      23                 :             : 
      24                 :             : #include <js/CallAndConstruct.h>  // for IsCallable, JS_CallFunctionValue
      25                 :             : #include <js/CallArgs.h>
      26                 :             : #include <js/CharacterEncoding.h>
      27                 :             : #include <js/Class.h>
      28                 :             : #include <js/ComparisonOperators.h>
      29                 :             : #include <js/ErrorReport.h>         // for JS_ReportOutOfMemory
      30                 :             : #include <js/GCAPI.h>               // for JS_AddWeakPointerCompartmentCallback
      31                 :             : #include <js/GCVector.h>            // for MutableWrappedPtrOperations
      32                 :             : #include <js/HeapAPI.h>
      33                 :             : #include <js/MemoryFunctions.h>     // for AddAssociatedMemory, RemoveAssoci...
      34                 :             : #include <js/PropertyAndElement.h>
      35                 :             : #include <js/PropertyDescriptor.h>  // for JSPROP_PERMANENT, JSPROP_READONLY
      36                 :             : #include <js/String.h>
      37                 :             : #include <js/Symbol.h>
      38                 :             : #include <js/TypeDecls.h>
      39                 :             : #include <js/Utility.h>  // for UniqueChars
      40                 :             : #include <js/Value.h>
      41                 :             : #include <js/ValueArray.h>
      42                 :             : #include <js/Warnings.h>
      43                 :             : #include <jsapi.h>        // for JS_GetFunctionObject, IdVector
      44                 :             : #include <jsfriendapi.h>  // for JS_GetObjectFunction, GetFunctionNativeReserved
      45                 :             : #include <mozilla/HashTable.h>
      46                 :             : 
      47                 :             : #include "gi/arg-inl.h"
      48                 :             : #include "gi/arg.h"
      49                 :             : #include "gi/closure.h"
      50                 :             : #include "gi/cwrapper.h"
      51                 :             : #include "gi/function.h"
      52                 :             : #include "gi/gjs_gi_trace.h"
      53                 :             : #include "gi/object.h"
      54                 :             : #include "gi/repo.h"
      55                 :             : #include "gi/toggle.h"
      56                 :             : #include "gi/utils-inl.h"  // for gjs_int_to_pointer
      57                 :             : #include "gi/value.h"
      58                 :             : #include "gi/wrapperutils.h"
      59                 :             : #include "gjs/atoms.h"
      60                 :             : #include "gjs/context-private.h"
      61                 :             : #include "gjs/deprecation.h"
      62                 :             : #include "gjs/jsapi-class.h"
      63                 :             : #include "gjs/jsapi-util.h"
      64                 :             : #include "gjs/jsapi-util-args.h"
      65                 :             : #include "gjs/jsapi-util-root.h"
      66                 :             : #include "gjs/macros.h"
      67                 :             : #include "gjs/mem-private.h"
      68                 :             : #include "gjs/profiler-private.h"
      69                 :             : #include "util/log.h"
      70                 :             : 
      71                 :             : class JSTracer;
      72                 :             : 
      73                 :             : /* This is a trick to print out the sizes of the structs at compile time, in
      74                 :             :  * an error message. */
      75                 :             : // template <int s> struct Measure;
      76                 :             : // Measure<sizeof(ObjectInstance)> instance_size;
      77                 :             : // Measure<sizeof(ObjectPrototype)> prototype_size;
      78                 :             : 
      79                 :             : #if defined(__x86_64__) && defined(__clang__)
      80                 :             : /* This isn't meant to be comprehensive, but should trip on at least one CI job
      81                 :             :  * if sizeof(ObjectInstance) is increased. */
      82                 :             : static_assert(sizeof(ObjectInstance) <= 64,
      83                 :             :               "Think very hard before increasing the size of ObjectInstance. "
      84                 :             :               "There can be tens of thousands of them alive in a typical "
      85                 :             :               "gnome-shell run.");
      86                 :             : #endif  // x86-64 clang
      87                 :             : 
      88                 :             : bool ObjectInstance::s_weak_pointer_callback = false;
      89                 :             : decltype(ObjectInstance::s_wrapped_gobject_list)
      90                 :             :     ObjectInstance::s_wrapped_gobject_list;
      91                 :             : 
      92                 :             : static const auto DISPOSED_OBJECT = std::numeric_limits<uintptr_t>::max();
      93                 :             : 
      94                 :             : GJS_JSAPI_RETURN_CONVENTION
      95                 :             : static JSObject* gjs_lookup_object_prototype_from_info(JSContext*, GIBaseInfo*,
      96                 :             :                                                        GType);
      97                 :             : 
      98                 :             : // clang-format off
      99         [ +  + ]:        7252 : G_DEFINE_QUARK(gjs::custom-type, ObjectBase::custom_type)
     100         [ +  + ]:         498 : G_DEFINE_QUARK(gjs::custom-property, ObjectBase::custom_property)
     101         [ +  + ]:           3 : G_DEFINE_QUARK(gjs::instance-strings, ObjectBase::instance_strings)
     102         [ +  + ]:        1871 : G_DEFINE_QUARK(gjs::disposed, ObjectBase::disposed)
     103                 :             : // clang-format on
     104                 :             : 
     105                 :        6461 : [[nodiscard]] static GQuark gjs_object_priv_quark() {
     106                 :             :     static GQuark val = 0;
     107         [ +  + ]:        6461 :     if (G_UNLIKELY (!val))
     108                 :          29 :         val = g_quark_from_static_string ("gjs::private");
     109                 :             : 
     110                 :        6461 :     return val;
     111                 :             : }
     112                 :             : 
     113                 :        2752 : bool ObjectBase::is_custom_js_class() {
     114                 :        2752 :     return !!g_type_get_qdata(gtype(), ObjectBase::custom_type_quark());
     115                 :             : }
     116                 :             : 
     117                 :             : // Plain g_type_query fails and leaves @query uninitialized for dynamic types.
     118                 :             : // See https://gitlab.gnome.org/GNOME/glib/issues/623
     119                 :        3254 : void ObjectBase::type_query_dynamic_safe(GTypeQuery* query) {
     120                 :        3254 :     GType type = gtype();
     121         [ +  + ]:        4374 :     while (g_type_get_qdata(type, ObjectBase::custom_type_quark()))
     122                 :        1120 :         type = g_type_parent(type);
     123                 :             : 
     124                 :        3254 :     g_type_query(type, query);
     125                 :        3254 : }
     126                 :             : 
     127                 :        1552 : void ObjectInstance::link() {
     128                 :        1552 :     g_assert(std::find(s_wrapped_gobject_list.begin(),
     129                 :             :                        s_wrapped_gobject_list.end(),
     130                 :             :                        this) == s_wrapped_gobject_list.end());
     131                 :        1552 :     s_wrapped_gobject_list.push_back(this);
     132                 :        1552 : }
     133                 :             : 
     134                 :        1568 : void ObjectInstance::unlink() {
     135                 :        1568 :     Gjs::remove_one_from_unsorted_vector(&s_wrapped_gobject_list, this);
     136                 :        1568 : }
     137                 :             : 
     138                 :        7600 : const void* ObjectBase::jsobj_addr(void) const {
     139         [ +  + ]:        7600 :     if (is_prototype())
     140                 :         670 :         return nullptr;
     141                 :        6930 :     return to_instance()->m_wrapper.debug_addr();
     142                 :             : }
     143                 :             : 
     144                 :             : // Overrides GIWrapperBase::typecheck(). We only override the overload that
     145                 :             : // throws, so that we can throw our own more informative error.
     146                 :        1986 : bool ObjectBase::typecheck(JSContext* cx, JS::HandleObject obj,
     147                 :             :                            GIObjectInfo* expected_info, GType expected_gtype) {
     148         [ +  + ]:        1986 :     if (GIWrapperBase::typecheck(cx, obj, expected_info, expected_gtype))
     149                 :        1981 :         return true;
     150                 :             : 
     151                 :           5 :     gjs_throw(cx,
     152                 :             :               "This JS object wrapper isn't wrapping a GObject."
     153                 :             :               " If this is a custom subclass, are you sure you chained"
     154                 :             :               " up to the parent _init properly?");
     155                 :           5 :     return false;
     156                 :             : }
     157                 :             : 
     158                 :        3778 : bool ObjectInstance::check_gobject_disposed_or_finalized(
     159                 :             :     const char* for_what) const {
     160         [ +  + ]:        3778 :     if (!m_gobj_disposed)
     161                 :        3738 :         return true;
     162                 :             : 
     163         [ +  + ]:          40 :     g_critical(
     164                 :             :         "Object %s.%s (%p), has been already %s — impossible to %s "
     165                 :             :         "it. This might be caused by the object having been destroyed from C "
     166                 :             :         "code using something such as destroy(), dispose(), or remove() "
     167                 :             :         "vfuncs.\n%s",
     168                 :             :         ns(), name(), m_ptr.get(), m_gobj_finalized ? "finalized" : "disposed",
     169                 :             :         for_what, gjs_dumpstack_string().c_str());
     170                 :          40 :     return false;
     171                 :             : }
     172                 :             : 
     173                 :        2723 : bool ObjectInstance::check_gobject_finalized(const char* for_what) const {
     174         [ +  + ]:        2723 :     if (check_gobject_disposed_or_finalized(for_what))
     175                 :        2689 :         return true;
     176                 :             : 
     177                 :          34 :     return !m_gobj_finalized;
     178                 :             : }
     179                 :             : 
     180                 :             : ObjectInstance *
     181                 :        2967 : ObjectInstance::for_gobject(GObject *gobj)
     182                 :             : {
     183                 :        2967 :     auto priv = static_cast<ObjectInstance *>(g_object_get_qdata(gobj,
     184                 :             :                                                                  gjs_object_priv_quark()));
     185                 :             : 
     186         [ +  + ]:        2967 :     if (priv)
     187                 :        1914 :         priv->check_js_object_finalized();
     188                 :             : 
     189                 :        2967 :     return priv;
     190                 :             : }
     191                 :             : 
     192                 :             : void
     193                 :        1914 : ObjectInstance::check_js_object_finalized(void)
     194                 :             : {
     195         [ +  + ]:        1914 :     if (!m_uses_toggle_ref)
     196                 :         287 :         return;
     197         [ -  + ]:        1627 :     if (G_UNLIKELY(m_wrapper_finalized)) {
     198                 :           0 :         g_critical(
     199                 :             :             "Object %p (a %s) resurfaced after the JS wrapper was finalized. "
     200                 :             :             "This is some library doing dubious memory management inside "
     201                 :             :             "dispose()",
     202                 :             :             m_ptr.get(), type_name());
     203                 :           0 :         m_wrapper_finalized = false;
     204                 :           0 :         g_assert(!m_wrapper);  /* should associate again with a new wrapper */
     205                 :             :     }
     206                 :             : }
     207                 :             : 
     208                 :         136 : ObjectPrototype* ObjectPrototype::for_gtype(GType gtype) {
     209                 :             :     return static_cast<ObjectPrototype*>(
     210                 :         136 :         g_type_get_qdata(gtype, gjs_object_priv_quark()));
     211                 :             : }
     212                 :             : 
     213                 :         117 : void ObjectPrototype::set_type_qdata(void) {
     214                 :         117 :     g_type_set_qdata(m_gtype, gjs_object_priv_quark(), this);
     215                 :         117 : }
     216                 :             : 
     217                 :             : void
     218                 :        1552 : ObjectInstance::set_object_qdata(void)
     219                 :             : {
     220                 :        1552 :     g_object_set_qdata_full(
     221                 :        1553 :         m_ptr, gjs_object_priv_quark(), this, [](void* object) {
     222                 :           1 :             auto* self = static_cast<ObjectInstance*>(object);
     223         [ -  + ]:           1 :             if (G_UNLIKELY(!self->m_gobj_disposed)) {
     224                 :           0 :                 g_warning(
     225                 :             :                     "Object %p (a %s) was finalized but we didn't track "
     226                 :             :                     "its disposal",
     227                 :             :                     self->m_ptr.get(), g_type_name(self->gtype()));
     228                 :           0 :                 self->m_gobj_disposed = true;
     229                 :             :             }
     230                 :           1 :             self->m_gobj_finalized = true;
     231                 :             :             gjs_debug_lifecycle(GJS_DEBUG_GOBJECT,
     232                 :             :                                 "Wrapped GObject %p finalized",
     233                 :             :                                 self->m_ptr.get());
     234                 :           1 :         });
     235                 :        1552 : }
     236                 :             : 
     237                 :             : void
     238                 :        1689 : ObjectInstance::unset_object_qdata(void)
     239                 :             : {
     240                 :        1689 :     auto priv_quark = gjs_object_priv_quark();
     241         [ +  + ]:        1689 :     if (g_object_get_qdata(m_ptr, priv_quark) == this)
     242                 :        1550 :         g_object_steal_qdata(m_ptr, priv_quark);
     243                 :        1689 : }
     244                 :             : 
     245                 :         605 : GParamSpec* ObjectPrototype::find_param_spec_from_id(
     246                 :             :     JSContext* cx, GjsAutoTypeClass<GObjectClass> const& object_class,
     247                 :             :     JS::HandleString key) {
     248                 :             :     /* First check for the ID in the cache */
     249                 :             : 
     250                 :         605 :     JS::UniqueChars js_prop_name(JS_EncodeStringToUTF8(cx, key));
     251         [ -  + ]:         605 :     if (!js_prop_name)
     252                 :           0 :         return nullptr;
     253                 :             : 
     254                 :         605 :     GjsAutoChar gname = gjs_hyphen_from_camel(js_prop_name.get());
     255                 :         605 :     GParamSpec* pspec = g_object_class_find_property(object_class, gname);
     256                 :             : 
     257         [ +  + ]:         605 :     if (!pspec) {
     258                 :           2 :         gjs_wrapper_throw_nonexistent_field(cx, m_gtype, js_prop_name.get());
     259                 :           2 :         return nullptr;
     260                 :             :     }
     261                 :             : 
     262                 :         603 :     return pspec;
     263                 :         605 : }
     264                 :             : 
     265                 :             : /* A hook on adding a property to an object. This is called during a set
     266                 :             :  * property operation after all the resolve hooks on the prototype chain have
     267                 :             :  * failed to resolve. We use this to mark an object as needing toggle refs when
     268                 :             :  * custom state is set on it, because we need to keep the JS GObject wrapper
     269                 :             :  * alive in order not to lose custom "expando" properties.
     270                 :             :  */
     271                 :        9342 : bool ObjectBase::add_property(JSContext* cx, JS::HandleObject obj,
     272                 :             :                               JS::HandleId id, JS::HandleValue value) {
     273                 :        9342 :     auto* priv = ObjectBase::for_js(cx, obj);
     274                 :             : 
     275                 :             :     /* priv is null during init: property is not being added from JS */
     276         [ +  + ]:        9342 :     if (!priv) {
     277                 :        1540 :         debug_jsprop_static("Add property hook", id, obj);
     278                 :        1540 :         return true;
     279                 :             :     }
     280         [ +  + ]:        7802 :     if (priv->is_prototype())
     281                 :        6127 :         return true;
     282                 :             : 
     283                 :        1675 :     return priv->to_instance()->add_property_impl(cx, obj, id, value);
     284                 :             : }
     285                 :             : 
     286                 :        1675 : bool ObjectInstance::add_property_impl(JSContext* cx, JS::HandleObject obj,
     287                 :             :                                        JS::HandleId id, JS::HandleValue) {
     288                 :        1675 :     debug_jsprop("Add property hook", id, obj);
     289                 :             : 
     290         [ +  + ]:        1675 :     if (is_custom_js_class())
     291                 :        1040 :         return true;
     292                 :             : 
     293                 :         635 :     ensure_uses_toggle_ref(cx);
     294                 :         635 :     return true;
     295                 :             : }
     296                 :             : 
     297                 :         479 : bool ObjectBase::prop_getter(JSContext* cx, unsigned argc, JS::Value* vp) {
     298   [ -  +  -  + ]:         479 :     GJS_CHECK_WRAPPER_PRIV(cx, argc, vp, args, obj, ObjectBase, priv);
     299                 :             : 
     300                 :             :     auto* pspec = static_cast<GParamSpec*>(
     301                 :         479 :         gjs_dynamic_property_private_slot(&args.callee()).toPrivate());
     302                 :             : 
     303                 :         479 :     std::string fullName{priv->format_name() + "[\"" + pspec->name + "\"]"};
     304                 :         479 :     AutoProfilerLabel label(cx, "property getter", fullName.c_str());
     305                 :             : 
     306                 :         479 :     priv->debug_jsprop("Property getter", pspec->name, obj);
     307                 :             : 
     308         [ +  + ]:         479 :     if (priv->is_prototype())
     309                 :         155 :         return true;
     310                 :             :         /* Ignore silently; note that this is different from what we do for
     311                 :             :          * boxed types, for historical reasons */
     312                 :             : 
     313                 :         324 :     return priv->to_instance()->prop_getter_impl(cx, pspec, args.rval());
     314                 :         479 : }
     315                 :             : 
     316                 :         324 : bool ObjectInstance::prop_getter_impl(JSContext* cx, GParamSpec* param,
     317                 :             :                                       JS::MutableHandleValue rval) {
     318         [ +  + ]:         324 :     if (!check_gobject_finalized("get any property from")) {
     319                 :           2 :         rval.setUndefined();
     320                 :           2 :         return true;
     321                 :             :     }
     322                 :             : 
     323         [ -  + ]:         322 :     if (param->flags & G_PARAM_DEPRECATED) {
     324                 :           0 :         const std::string& class_name = format_name();
     325                 :           0 :         _gjs_warn_deprecated_once_per_callsite(
     326                 :           0 :             cx, DeprecatedGObjectProperty, {class_name.c_str(), param->name});
     327                 :           0 :     }
     328                 :             : 
     329         [ +  + ]:         322 :     if ((param->flags & G_PARAM_READABLE) == 0) {
     330                 :           1 :         rval.setUndefined();
     331                 :           1 :         return true;
     332                 :             :     }
     333                 :             : 
     334                 :             :     gjs_debug_jsprop(GJS_DEBUG_GOBJECT, "Accessing GObject property %s",
     335                 :             :                      param->name);
     336                 :             : 
     337                 :         321 :     Gjs::AutoGValue gvalue(G_PARAM_SPEC_VALUE_TYPE(param));
     338                 :         321 :     g_object_get_property(m_ptr, param->name, &gvalue);
     339                 :             : 
     340                 :         321 :     return gjs_value_from_g_value(cx, rval, &gvalue);
     341                 :         321 : }
     342                 :             : 
     343                 :        3615 : [[nodiscard]] static GjsAutoFieldInfo lookup_field_info(GIObjectInfo* info,
     344                 :             :                                                         const char* name) {
     345                 :        3615 :     int n_fields = g_object_info_get_n_fields(info);
     346                 :             :     int ix;
     347                 :        3615 :     GjsAutoFieldInfo retval;
     348                 :             : 
     349         [ +  + ]:       12460 :     for (ix = 0; ix < n_fields; ix++) {
     350                 :        8850 :         retval = g_object_info_get_field(info, ix);
     351         [ +  + ]:        8850 :         if (strcmp(name, retval.name()) == 0)
     352                 :           5 :             break;
     353                 :        8845 :         retval.reset();
     354                 :             :     }
     355                 :             : 
     356   [ +  +  -  +  :        3615 :     if (!retval || !(g_field_info_get_flags(retval) & GI_FIELD_IS_READABLE))
                   +  + ]
     357                 :        3610 :         return nullptr;
     358                 :             : 
     359                 :           5 :     return retval;
     360                 :        3615 : }
     361                 :             : 
     362                 :           8 : bool ObjectBase::field_getter(JSContext* cx, unsigned argc, JS::Value* vp) {
     363   [ -  +  -  + ]:           8 :     GJS_CHECK_WRAPPER_PRIV(cx, argc, vp, args, obj, ObjectBase, priv);
     364                 :             : 
     365                 :             :     JS::RootedString name(cx,
     366                 :           8 :         gjs_dynamic_property_private_slot(&args.callee()).toString());
     367                 :             : 
     368                 :          16 :     std::string fullName{priv->format_name() + "[" + gjs_debug_string(name) +
     369                 :           8 :                          "]"};
     370                 :           8 :     AutoProfilerLabel label(cx, "field getter", fullName.c_str());
     371                 :             : 
     372                 :           8 :     priv->debug_jsprop("Field getter", name, obj);
     373                 :             : 
     374         [ -  + ]:           8 :     if (priv->is_prototype())
     375                 :           0 :         return true;
     376                 :             :         /* Ignore silently; note that this is different from what we do for
     377                 :             :          * boxed types, for historical reasons */
     378                 :             : 
     379                 :           8 :     return priv->to_instance()->field_getter_impl(cx, name, args.rval());
     380                 :           8 : }
     381                 :             : 
     382                 :           8 : bool ObjectInstance::field_getter_impl(JSContext* cx, JS::HandleString name,
     383                 :             :                                        JS::MutableHandleValue rval) {
     384         [ -  + ]:           8 :     if (!check_gobject_finalized("get any property from"))
     385                 :           0 :         return true;
     386                 :             : 
     387                 :           8 :     ObjectPrototype* proto_priv = get_prototype();
     388                 :           8 :     GIFieldInfo* field = proto_priv->lookup_cached_field_info(cx, name);
     389                 :             :     GITypeTag tag;
     390                 :           8 :     GIArgument arg = { 0 };
     391                 :             : 
     392                 :             :     gjs_debug_jsprop(GJS_DEBUG_GOBJECT, "Overriding %s with GObject field",
     393                 :             :                      gjs_debug_string(name).c_str());
     394                 :             : 
     395                 :           8 :     GjsAutoTypeInfo type = g_field_info_get_type(field);
     396                 :           8 :     tag = g_type_info_get_tag(type);
     397                 :             : 
     398         [ +  + ]:           8 :     switch (tag) {
     399                 :           2 :         case GI_TYPE_TAG_ARRAY:
     400                 :             :         case GI_TYPE_TAG_ERROR:
     401                 :             :         case GI_TYPE_TAG_GHASH:
     402                 :             :         case GI_TYPE_TAG_GLIST:
     403                 :             :         case GI_TYPE_TAG_GSLIST:
     404                 :             :         case GI_TYPE_TAG_INTERFACE:
     405                 :           4 :             gjs_throw(cx,
     406                 :             :                       "Can't get field %s; GObject introspection supports only "
     407                 :             :                       "fields with simple types, not %s",
     408                 :           4 :                       gjs_debug_string(name).c_str(),
     409                 :             :                       g_type_tag_to_string(tag));
     410                 :           2 :             return false;
     411                 :             : 
     412                 :           6 :         default:
     413                 :           6 :             break;
     414                 :             :     }
     415                 :             : 
     416         [ -  + ]:           6 :     if (!g_field_info_get_field(field, m_ptr, &arg)) {
     417                 :           0 :         gjs_throw(cx, "Error getting field %s from object",
     418                 :           0 :                   gjs_debug_string(name).c_str());
     419                 :           0 :         return false;
     420                 :             :     }
     421                 :             : 
     422                 :           6 :     return gjs_value_from_gi_argument(cx, rval, type, GJS_ARGUMENT_FIELD,
     423                 :           6 :                                       GI_TRANSFER_EVERYTHING, &arg);
     424                 :             :     /* transfer is irrelevant because g_field_info_get_field() doesn't
     425                 :             :      * handle boxed types */
     426                 :           8 : }
     427                 :             : 
     428                 :             : /* Dynamic setter for GObject properties. Returns false on OOM/exception.
     429                 :             :  * args.rval() becomes the "stored value" for the property. */
     430                 :         195 : bool ObjectBase::prop_setter(JSContext* cx, unsigned argc, JS::Value* vp) {
     431   [ -  +  -  + ]:         195 :     GJS_CHECK_WRAPPER_PRIV(cx, argc, vp, args, obj, ObjectBase, priv);
     432                 :             : 
     433                 :             :     auto* pspec = static_cast<GParamSpec*>(
     434                 :         195 :         gjs_dynamic_property_private_slot(&args.callee()).toPrivate());
     435                 :             : 
     436                 :         195 :     std::string fullName{priv->format_name() + "[\"" + pspec->name + "\"]"};
     437                 :         195 :     AutoProfilerLabel label(cx, "property setter", fullName.c_str());
     438                 :             : 
     439                 :         195 :     priv->debug_jsprop("Property setter", pspec->name, obj);
     440                 :             : 
     441         [ -  + ]:         195 :     if (priv->is_prototype())
     442                 :           0 :         return true;
     443                 :             :         /* Ignore silently; note that this is different from what we do for
     444                 :             :          * boxed types, for historical reasons */
     445                 :             : 
     446                 :             :     /* Clear the JS stored value, to avoid keeping additional references */
     447                 :         195 :     args.rval().setUndefined();
     448                 :             : 
     449                 :         195 :     return priv->to_instance()->prop_setter_impl(cx, pspec, args[0]);
     450                 :         195 : }
     451                 :             : 
     452                 :         195 : bool ObjectInstance::prop_setter_impl(JSContext* cx, GParamSpec* param_spec,
     453                 :             :                                       JS::HandleValue value) {
     454         [ +  + ]:         195 :     if (!check_gobject_finalized("set any property on"))
     455                 :           1 :         return true;
     456                 :             : 
     457         [ +  + ]:         194 :     if (!(param_spec->flags & G_PARAM_WRITABLE))
     458                 :             :         /* prevent setting the prop even in JS */
     459                 :           1 :         return gjs_wrapper_throw_readonly_field(cx, gtype(), param_spec->name);
     460                 :             : 
     461         [ -  + ]:         193 :     if (param_spec->flags & G_PARAM_DEPRECATED) {
     462                 :           0 :         const std::string& class_name = format_name();
     463                 :           0 :         _gjs_warn_deprecated_once_per_callsite(
     464                 :             :             cx, DeprecatedGObjectProperty,
     465                 :           0 :             {class_name.c_str(), param_spec->name});
     466                 :           0 :     }
     467                 :             : 
     468                 :             :     gjs_debug_jsprop(GJS_DEBUG_GOBJECT, "Setting GObject prop %s",
     469                 :             :                      param_spec->name);
     470                 :             : 
     471                 :         193 :     Gjs::AutoGValue gvalue(G_PARAM_SPEC_VALUE_TYPE(param_spec));
     472         [ +  + ]:         193 :     if (!gjs_value_to_g_value(cx, value, &gvalue))
     473                 :           7 :         return false;
     474                 :             : 
     475                 :         186 :     g_object_set_property(m_ptr, param_spec->name, &gvalue);
     476                 :             : 
     477                 :         186 :     return true;
     478                 :         193 : }
     479                 :             : 
     480                 :           1 : bool ObjectBase::field_setter(JSContext* cx, unsigned argc, JS::Value* vp) {
     481   [ -  +  -  + ]:           1 :     GJS_CHECK_WRAPPER_PRIV(cx, argc, vp, args, obj, ObjectBase, priv);
     482                 :             : 
     483                 :             :     JS::RootedString name(cx,
     484                 :           1 :         gjs_dynamic_property_private_slot(&args.callee()).toString());
     485                 :             : 
     486                 :           2 :     std::string fullName{priv->format_name() + "[" + gjs_debug_string(name) +
     487                 :           1 :                          "]"};
     488                 :           1 :     AutoProfilerLabel label(cx, "field setter", fullName.c_str());
     489                 :             : 
     490                 :           1 :     priv->debug_jsprop("Field setter", name, obj);
     491                 :             : 
     492         [ -  + ]:           1 :     if (priv->is_prototype())
     493                 :           0 :         return true;
     494                 :             :         /* Ignore silently; note that this is different from what we do for
     495                 :             :          * boxed types, for historical reasons */
     496                 :             : 
     497                 :             :     /* We have to update args.rval(), because JS caches it as the property's "stored
     498                 :             :      * value" (https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/JSAPI_reference/Stored_value)
     499                 :             :      * and so subsequent gets would get the stored value instead of accessing
     500                 :             :      * the field */
     501                 :           1 :     args.rval().setUndefined();
     502                 :             : 
     503                 :           1 :     return priv->to_instance()->field_setter_not_impl(cx, name);
     504                 :           1 : }
     505                 :             : 
     506                 :           1 : bool ObjectInstance::field_setter_not_impl(JSContext* cx,
     507                 :             :                                            JS::HandleString name) {
     508         [ -  + ]:           1 :     if (!check_gobject_finalized("set GObject field on"))
     509                 :           0 :         return true;
     510                 :             : 
     511                 :           1 :     ObjectPrototype* proto_priv = get_prototype();
     512                 :           1 :     GIFieldInfo* field = proto_priv->lookup_cached_field_info(cx, name);
     513                 :             : 
     514                 :             :     /* As far as I know, GI never exposes GObject instance struct fields as
     515                 :             :      * writable, so no need to implement this for the time being */
     516         [ -  + ]:           1 :     if (g_field_info_get_flags(field) & GI_FIELD_IS_WRITABLE) {
     517                 :           0 :         g_message("Field %s of a GObject is writable, but setting it is not "
     518                 :             :                   "implemented", gjs_debug_string(name).c_str());
     519                 :           0 :         return true;
     520                 :             :     }
     521                 :             : 
     522                 :           1 :     return gjs_wrapper_throw_readonly_field(cx, gtype(),
     523                 :           1 :                                             g_base_info_get_name(field));
     524                 :             : }
     525                 :             : 
     526                 :           0 : bool ObjectPrototype::is_vfunc_unchanged(GIVFuncInfo* info) {
     527                 :           0 :     GjsAutoError error;
     528                 :           0 :     GType ptype = g_type_parent(m_gtype);
     529                 :             :     gpointer addr1, addr2;
     530                 :             : 
     531                 :           0 :     addr1 = g_vfunc_info_get_address(info, m_gtype, &error);
     532         [ #  # ]:           0 :     if (error)
     533                 :           0 :         return false;
     534                 :             : 
     535                 :           0 :     addr2 = g_vfunc_info_get_address(info, ptype, &error);
     536         [ #  # ]:           0 :     if (error)
     537                 :           0 :         return false;
     538                 :             : 
     539                 :           0 :     return addr1 == addr2;
     540                 :           0 : }
     541                 :             : 
     542                 :          18 : [[nodiscard]] static GjsAutoVFuncInfo find_vfunc_on_parents(
     543                 :             :     GIObjectInfo* info, const char* name, bool* out_defined_by_parent) {
     544                 :          18 :     bool defined_by_parent = false;
     545                 :             : 
     546                 :             :     /* ref the first info so that we don't destroy
     547                 :             :      * it when unrefing parents later */
     548                 :          18 :     GjsAutoObjectInfo parent(info, GjsAutoTakeOwnership());
     549                 :             : 
     550                 :             :     /* Since it isn't possible to override a vfunc on
     551                 :             :      * an interface without reimplementing it, we don't need
     552                 :             :      * to search the parent types when looking for a vfunc. */
     553                 :             :     GjsAutoVFuncInfo vfunc =
     554                 :          18 :         g_object_info_find_vfunc_using_interfaces(parent, name, nullptr);
     555   [ +  +  +  +  :          51 :     while (!vfunc && parent) {
                   +  + ]
     556                 :          33 :         parent = g_object_info_get_parent(parent);
     557         [ +  + ]:          33 :         if (parent)
     558                 :          16 :             vfunc = g_object_info_find_vfunc(parent, name);
     559                 :             : 
     560                 :          33 :         defined_by_parent = true;
     561                 :             :     }
     562                 :             : 
     563         [ +  - ]:          18 :     if (out_defined_by_parent)
     564                 :          18 :         *out_defined_by_parent = defined_by_parent;
     565                 :             : 
     566                 :          18 :     return vfunc;
     567                 :          18 : }
     568                 :             : 
     569                 :             : /* Taken from GLib */
     570                 :        3414 : static void canonicalize_key(const GjsAutoChar& key) {
     571         [ +  + ]:       42444 :     for (char* p = key; *p != 0; p++) {
     572                 :       39030 :         char c = *p;
     573                 :             : 
     574   [ +  +  +  +  :       39030 :         if (c != '-' && (c < '0' || c > '9') && (c < 'A' || c > 'Z') &&
          +  +  +  +  +  
                -  +  + ]
     575         [ -  + ]:       35042 :             (c < 'a' || c > 'z'))
     576                 :        2797 :             *p = '-';
     577                 :             :     }
     578                 :        3414 : }
     579                 :             : 
     580                 :             : /* @name must already be canonicalized */
     581                 :        1369 : [[nodiscard]] static bool is_ginterface_property_name(GIInterfaceInfo* info,
     582                 :             :                                                       const char* name) {
     583                 :        1369 :     int n_props = g_interface_info_get_n_properties(info);
     584                 :        1369 :     GjsAutoPropertyInfo prop_info;
     585                 :             : 
     586         [ +  + ]:        1512 :     for (int ix = 0; ix < n_props; ix++) {
     587                 :         148 :         prop_info = g_interface_info_get_property(info, ix);
     588         [ +  + ]:         148 :         if (strcmp(name, prop_info.name()) == 0)
     589                 :           5 :             break;
     590                 :         143 :         prop_info.reset();
     591                 :             :     }
     592                 :             : 
     593                 :        1369 :     return !!prop_info;
     594                 :        1369 : }
     595                 :             : 
     596                 :         246 : bool ObjectPrototype::lazy_define_gobject_property(
     597                 :             :     JSContext* cx, JS::HandleObject obj, JS::HandleId id, GParamSpec* pspec,
     598                 :             :     bool* resolved, const char* name) {
     599                 :         246 :     bool found = false;
     600         [ -  + ]:         246 :     if (!JS_AlreadyHasOwnPropertyById(cx, obj, id, &found))
     601                 :           0 :         return false;
     602         [ -  + ]:         246 :     if (found) {
     603                 :             :         /* Already defined, so *resolved = false because we didn't just
     604                 :             :          * define it */
     605                 :           0 :         *resolved = false;
     606                 :           0 :         return true;
     607                 :             :     }
     608                 :             : 
     609                 :         246 :     debug_jsprop("Defining lazy GObject property", id, obj);
     610                 :             : 
     611                 :             :     // Do not fetch JS overridden properties from GObject, to avoid
     612                 :             :     // infinite recursion.
     613         [ -  + ]:         246 :     if (g_param_spec_get_qdata(pspec, ObjectBase::custom_property_quark())) {
     614                 :           0 :         *resolved = false;
     615                 :           0 :         return true;
     616                 :             :     }
     617                 :             : 
     618                 :         246 :     JS::RootedValue private_value{cx, JS::PrivateValue(pspec)};
     619         [ -  + ]:         246 :     if (!gjs_define_property_dynamic(
     620                 :             :             cx, obj, name, id, "gobject_prop", &ObjectBase::prop_getter,
     621                 :             :             &ObjectBase::prop_setter, private_value,
     622                 :             :             // Make property configurable so that interface properties can be
     623                 :             :             // overridden by GObject.ParamSpec.override in the class that
     624                 :             :             // implements them
     625                 :             :             GJS_MODULE_PROP_FLAGS & ~JSPROP_PERMANENT))
     626                 :           0 :         return false;
     627                 :             : 
     628                 :         246 :     *resolved = true;
     629                 :         246 :     return true;
     630                 :         246 : }
     631                 :             : 
     632                 :             : // An object shared by the getter and setter to store the interface' prototype
     633                 :             : // and overrides.
     634                 :             : static constexpr size_t ACCESSOR_SLOT = 0;
     635                 :             : 
     636                 :         355 : static bool interface_getter(JSContext* cx, unsigned argc, JS::Value* vp) {
     637                 :         355 :     JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
     638                 :             : 
     639                 :             :     JS::RootedValue v_accessor(
     640                 :         355 :         cx, js::GetFunctionNativeReserved(&args.callee(), ACCESSOR_SLOT));
     641                 :         355 :     g_assert(v_accessor.isObject() && "accessor must be an object");
     642                 :         355 :     JS::RootedObject accessor(cx, &v_accessor.toObject());
     643                 :             : 
     644                 :         355 :     const GjsAtoms& atoms = GjsContextPrivate::atoms(cx);
     645                 :             : 
     646                 :             :     // Check if an override value has been set
     647                 :         355 :     bool has_override_symbol = false;
     648         [ -  + ]:         355 :     if (!JS_HasPropertyById(cx, accessor, atoms.override(),
     649                 :             :                             &has_override_symbol))
     650                 :           0 :         return false;
     651                 :             : 
     652         [ +  + ]:         355 :     if (has_override_symbol) {
     653                 :          45 :         JS::RootedValue v_override_symbol(cx);
     654         [ -  + ]:          45 :         if (!JS_GetPropertyById(cx, accessor, atoms.override(),
     655                 :             :                                 &v_override_symbol))
     656                 :           0 :             return false;
     657                 :          45 :         g_assert(v_override_symbol.isSymbol() &&
     658                 :             :                  "override symbol must be a symbol");
     659                 :          45 :         JS::RootedSymbol override_symbol(cx, v_override_symbol.toSymbol());
     660                 :          45 :         JS::RootedId override_id(cx, JS::PropertyKey::Symbol(override_symbol));
     661                 :             : 
     662                 :          45 :         JS::RootedObject this_obj(cx);
     663         [ -  + ]:          45 :         if (!args.computeThis(cx, &this_obj))
     664                 :           0 :             return false;
     665                 :             : 
     666                 :          45 :         bool has_override = false;
     667         [ -  + ]:          45 :         if (!JS_HasPropertyById(cx, this_obj, override_id, &has_override))
     668                 :           0 :             return false;
     669                 :             : 
     670         [ +  + ]:          45 :         if (has_override)
     671                 :          40 :             return JS_GetPropertyById(cx, this_obj, override_id, args.rval());
     672   [ +  +  +  +  :         165 :     }
             +  +  +  + ]
     673                 :             : 
     674                 :         315 :     JS::RootedValue v_prototype(cx);
     675         [ -  + ]:         315 :     if (!JS_GetPropertyById(cx, accessor, atoms.prototype(), &v_prototype))
     676                 :           0 :         return false;
     677                 :         315 :     g_assert(v_prototype.isObject() && "prototype must be an object");
     678                 :             : 
     679                 :         315 :     JS::RootedObject prototype(cx, &v_prototype.toObject());
     680                 :         315 :     JS::RootedId id(cx, JS::PropertyKey::NonIntAtom(JS_GetFunctionId(
     681                 :         630 :                             JS_GetObjectFunction(&args.callee()))));
     682                 :         315 :     return JS_GetPropertyById(cx, prototype, id, args.rval());
     683                 :         355 : }
     684                 :             : 
     685                 :          74 : static bool interface_setter(JSContext* cx, unsigned argc, JS::Value* vp) {
     686                 :          74 :     JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
     687                 :             :     JS::RootedValue v_accessor(
     688                 :          74 :         cx, js::GetFunctionNativeReserved(&args.callee(), ACCESSOR_SLOT));
     689                 :          74 :     JS::RootedObject accessor(cx, &v_accessor.toObject());
     690                 :             :     JS::RootedString description(
     691                 :          74 :         cx, JS_AtomizeAndPinString(cx, "Private interface function setter"));
     692                 :          74 :     JS::RootedSymbol symbol(cx, JS::NewSymbol(cx, description));
     693                 :          74 :     JS::RootedValue v_symbol(cx, JS::SymbolValue(symbol));
     694                 :             : 
     695                 :          74 :     const GjsAtoms& atoms = GjsContextPrivate::atoms(cx);
     696         [ -  + ]:          74 :     if (!JS_SetPropertyById(cx, accessor, atoms.override(), v_symbol))
     697                 :           0 :         return false;
     698                 :             : 
     699                 :          74 :     args.rval().setUndefined();
     700                 :             : 
     701                 :          74 :     JS::RootedObject this_obj(cx);
     702         [ -  + ]:          74 :     if (!args.computeThis(cx, &this_obj))
     703                 :           0 :         return false;
     704                 :          74 :     JS::RootedId override_id(cx, JS::PropertyKey::Symbol(symbol));
     705                 :             : 
     706                 :          74 :     return JS_SetPropertyById(cx, this_obj, override_id, args[0]);
     707                 :          74 : }
     708                 :             : 
     709                 :         769 : static bool resolve_on_interface_prototype(JSContext* cx,
     710                 :             :                                            GIInterfaceInfo* iface_info,
     711                 :             :                                            JS::HandleId identifier,
     712                 :             :                                            JS::HandleObject class_prototype,
     713                 :             :                                            bool* found) {
     714                 :         769 :     GType gtype = g_base_info_get_type(iface_info);
     715                 :             :     JS::RootedObject interface_prototype(
     716                 :         769 :         cx, gjs_lookup_object_prototype_from_info(cx, iface_info, gtype));
     717         [ -  + ]:         769 :     if (!interface_prototype)
     718                 :           0 :         return false;
     719                 :             : 
     720                 :         769 :     bool exists = false;
     721         [ -  + ]:         769 :     if (!JS_HasPropertyById(cx, interface_prototype, identifier, &exists))
     722                 :           0 :         return false;
     723                 :             : 
     724                 :             :     // If the property doesn't exist on the interface prototype, we don't need
     725                 :             :     // to perform this trick.
     726         [ +  + ]:         769 :     if (!exists) {
     727                 :         661 :         *found = false;
     728                 :         661 :         return true;
     729                 :             :     }
     730                 :             : 
     731                 :             :     // Lazily define a property on the class prototype if a property
     732                 :             :     // of that name is present on an interface prototype that the class
     733                 :             :     // implements.
     734                 :             :     //
     735                 :             :     // Define a property of the same name on the class prototype, with a
     736                 :             :     // getter and setter. This is so that e.g. file.dup() calls the _current_
     737                 :             :     // value of Gio.File.prototype.dup(), not the original, so that it can be
     738                 :             :     // overridden (or monkeypatched).
     739                 :             :     //
     740                 :             :     // The setter (interface_setter() above) marks the property as overridden if
     741                 :             :     // it is set from user code. The getter (interface_getter() above) proxies
     742                 :             :     // the interface prototype's property, unless it was marked as overridden.
     743                 :             :     //
     744                 :             :     // Store the identifier in the getter and setter function's ID slots for
     745                 :             :     // to enable looking up the original value on the interface prototype.
     746                 :             :     JS::RootedObject getter(
     747                 :         108 :         cx, JS_GetFunctionObject(js::NewFunctionByIdWithReserved(
     748                 :         108 :                 cx, interface_getter, 0, 0, identifier)));
     749         [ -  + ]:         108 :     if (!getter)
     750                 :           0 :         return false;
     751                 :             : 
     752                 :             :     JS::RootedObject setter(
     753                 :         108 :         cx, JS_GetFunctionObject(js::NewFunctionByIdWithReserved(
     754                 :         108 :                 cx, interface_setter, 1, 0, identifier)));
     755         [ -  + ]:         108 :     if (!setter)
     756                 :           0 :         return false;
     757                 :             : 
     758                 :         108 :     JS::RootedObject accessor(cx, JS_NewPlainObject(cx));
     759         [ -  + ]:         108 :     if (!accessor)
     760                 :           0 :         return false;
     761                 :             : 
     762                 :         108 :     js::SetFunctionNativeReserved(setter, ACCESSOR_SLOT,
     763                 :         108 :                                   JS::ObjectValue(*accessor));
     764                 :         108 :     js::SetFunctionNativeReserved(getter, ACCESSOR_SLOT,
     765                 :         108 :                                   JS::ObjectValue(*accessor));
     766                 :             : 
     767                 :         108 :     const GjsAtoms& atoms = GjsContextPrivate::atoms(cx);
     768                 :         108 :     JS::RootedValue v_prototype(cx, JS::ObjectValue(*interface_prototype));
     769         [ -  + ]:         108 :     if (!JS_SetPropertyById(cx, accessor, atoms.prototype(), v_prototype))
     770                 :           0 :         return false;
     771                 :             : 
     772                 :             :     // Create a new descriptor with our getter and setter, that is configurable
     773                 :             :     // and enumerable, because GObject may need to redefine it later.
     774                 :         108 :     JS::PropertyAttributes attrs{JS::PropertyAttribute::Configurable,
     775                 :             :                                  JS::PropertyAttribute::Enumerable};
     776                 :             :     JS::Rooted<JS::PropertyDescriptor> desc(
     777                 :         108 :         cx, JS::PropertyDescriptor::Accessor(getter, setter, attrs));
     778                 :             : 
     779         [ -  + ]:         108 :     if (!JS_DefinePropertyById(cx, class_prototype, identifier, desc))
     780                 :           0 :         return false;
     781                 :             : 
     782                 :         108 :     *found = true;
     783                 :         108 :     return true;
     784                 :         769 : }
     785                 :             : 
     786                 :        2172 : bool ObjectPrototype::resolve_no_info(JSContext* cx, JS::HandleObject obj,
     787                 :             :                                       JS::HandleId id, bool* resolved,
     788                 :             :                                       const char* name,
     789                 :             :                                       ResolveWhat resolve_props) {
     790                 :             :     guint n_interfaces;
     791                 :             :     guint i;
     792                 :             : 
     793                 :        2172 :     GjsAutoChar canonical_name;
     794         [ +  + ]:        2172 :     if (resolve_props == ConsiderMethodsAndProperties) {
     795                 :             :         // Optimization: GObject property names must start with a letter
     796         [ +  + ]:         356 :         if (g_ascii_isalpha(name[0])) {
     797                 :         183 :             canonical_name = gjs_hyphen_from_camel(name);
     798                 :         183 :             canonicalize_key(canonical_name);
     799                 :             :         }
     800                 :             :     }
     801                 :             : 
     802                 :             :     GIInterfaceInfo** interfaces;
     803                 :        2172 :     g_irepository_get_object_gtype_interfaces(nullptr, m_gtype, &n_interfaces,
     804                 :             :         &interfaces);
     805                 :             : 
     806                 :             :     /* Fallback to GType system for non custom GObjects with no GI information
     807                 :             :      */
     808   [ +  +  +  -  :        2172 :     if (canonical_name && G_TYPE_IS_CLASSED(m_gtype) && !is_custom_js_class()) {
             +  +  +  + ]
     809                 :          51 :         GjsAutoTypeClass<GObjectClass> oclass(m_gtype);
     810                 :             : 
     811         [ +  + ]:          51 :         if (GParamSpec* pspec =
     812                 :          51 :                 g_object_class_find_property(oclass, canonical_name))
     813                 :           4 :             return lazy_define_gobject_property(cx, obj, id, pspec, resolved,
     814                 :           4 :                                                 name);
     815                 :             : 
     816         [ +  + ]:          92 :         for (i = 0; i < n_interfaces; i++) {
     817                 :             :             GType iface_gtype =
     818                 :          45 :                 g_registered_type_info_get_g_type(interfaces[i]);
     819         [ +  - ]:          45 :             if (!G_TYPE_IS_CLASSED(iface_gtype))
     820                 :          45 :                 continue;
     821                 :             : 
     822                 :           0 :             GjsAutoTypeClass<GObjectClass> iclass(iface_gtype);
     823                 :             : 
     824         [ #  # ]:           0 :             if (GParamSpec* pspec =
     825                 :           0 :                     g_object_class_find_property(iclass, canonical_name))
     826                 :           0 :                 return lazy_define_gobject_property(cx, obj, id, pspec,
     827                 :           0 :                                                     resolved, name);
     828         [ #  # ]:           0 :         }
     829         [ +  + ]:          51 :     }
     830                 :             : 
     831         [ +  + ]:        2168 :     for (i = 0; i < n_interfaces; i++) {
     832                 :         692 :         GIInterfaceInfo* iface_info = interfaces[i];
     833                 :             :         GjsAutoFunctionInfo method_info =
     834                 :         692 :             g_interface_info_find_method(iface_info, name);
     835         [ +  + ]:         692 :         if (method_info) {
     836         [ +  - ]:          29 :             if (g_function_info_get_flags (method_info) & GI_FUNCTION_IS_METHOD) {
     837                 :          29 :                 bool found = false;
     838         [ -  + ]:          29 :                 if (!resolve_on_interface_prototype(cx, iface_info, id, obj,
     839                 :             :                                                     &found))
     840                 :           0 :                     return false;
     841                 :             : 
     842                 :             :                 // Fallback to defining the function from type info...
     843   [ -  +  -  -  :          29 :                 if (!found &&
                   -  + ]
     844                 :           0 :                     !gjs_define_function(cx, obj, m_gtype, method_info))
     845                 :           0 :                     return false;
     846                 :             : 
     847                 :          29 :                 *resolved = true;
     848                 :          29 :                 return true;
     849                 :             :             }
     850                 :             :         }
     851                 :             : 
     852                 :             : 
     853                 :             :         /* If the name refers to a GObject property, lazily define the property
     854                 :             :          * in JS as we do below in the real resolve hook. We ignore fields here
     855                 :             :          * because I don't think interfaces can have fields */
     856   [ +  +  +  +  :         711 :         if (canonical_name &&
                   +  + ]
     857                 :         711 :             is_ginterface_property_name(iface_info, canonical_name)) {
     858                 :           3 :             GjsAutoTypeClass<GObjectClass> oclass(m_gtype);
     859                 :             :             // unowned
     860                 :           3 :             GParamSpec* pspec = g_object_class_find_property(
     861                 :             :                 oclass, canonical_name);  // unowned
     862   [ +  +  -  + ]:           3 :             if (pspec && pspec->owner_type == m_gtype) {
     863                 :           0 :                 return lazy_define_gobject_property(cx, obj, id, pspec,
     864                 :           0 :                                                     resolved, name);
     865                 :             :             }
     866         [ +  - ]:           3 :         }
     867                 :             : 
     868                 :         663 :         return resolve_on_interface_prototype(cx, iface_info, id, obj,
     869                 :         663 :                                               resolved);
     870                 :         692 :     }
     871                 :             : 
     872                 :        1476 :     *resolved = false;
     873                 :        1476 :     return true;
     874                 :        2172 : }
     875                 :             : 
     876                 :        3857 : [[nodiscard]] static GjsAutoChar get_gobject_property_name(GIObjectInfo* info,
     877                 :             :                                                            const char* name) {
     878                 :             :     // Optimization: GObject property names must start with a letter
     879         [ +  + ]:        3857 :     if (!g_ascii_isalpha(name[0]))
     880                 :         626 :         return nullptr;
     881                 :             : 
     882                 :        3231 :     int n_props = g_object_info_get_n_properties(info);
     883                 :        3231 :     int n_ifaces = g_object_info_get_n_interfaces(info);
     884                 :             :     int ix;
     885                 :             : 
     886                 :        3231 :     GjsAutoChar canonical_name = gjs_hyphen_from_camel(name);
     887                 :        3231 :     canonicalize_key(canonical_name);
     888                 :             : 
     889         [ +  + ]:       17428 :     for (ix = 0; ix < n_props; ix++) {
     890                 :       14437 :         GjsAutoPropertyInfo prop_info = g_object_info_get_property(info, ix);
     891         [ +  + ]:       14437 :         if (strcmp(canonical_name, prop_info.name()) == 0)
     892                 :         240 :             return canonical_name;
     893         [ +  + ]:       14437 :     }
     894                 :             : 
     895         [ +  + ]:        4310 :     for (ix = 0; ix < n_ifaces; ix++) {
     896                 :        1321 :         GjsAutoInterfaceInfo iface_info = g_object_info_get_interface(info, ix);
     897         [ +  + ]:        1321 :         if (is_ginterface_property_name(iface_info, canonical_name))
     898                 :           2 :             return canonical_name;
     899         [ +  + ]:        1321 :     }
     900                 :        2989 :     return nullptr;
     901                 :        3231 : }
     902                 :             : 
     903                 :             : // Override of GIWrapperBase::id_is_never_lazy()
     904                 :           0 : bool ObjectBase::id_is_never_lazy(jsid name, const GjsAtoms& atoms) {
     905                 :             :     // Keep this list in sync with ObjectBase::proto_properties and
     906                 :             :     // ObjectBase::proto_methods. However, explicitly do not include
     907                 :             :     // connect() in it, because there are a few cases where the lazy property
     908                 :             :     // should override the predefined one, such as Gio.Cancellable.connect().
     909   [ #  #  #  #  :           0 :     return name == atoms.init() || name == atoms.connect_after() ||
                   #  # ]
     910                 :           0 :            name == atoms.emit();
     911                 :             : }
     912                 :             : 
     913                 :       14360 : bool ObjectPrototype::resolve_impl(JSContext* context, JS::HandleObject obj,
     914                 :             :                                    JS::HandleId id, bool* resolved) {
     915         [ +  + ]:       14360 :     if (m_unresolvable_cache.has(id)) {
     916                 :        6570 :         *resolved = false;
     917                 :        6570 :         return true;
     918                 :             :     }
     919                 :             : 
     920                 :        7790 :     JS::UniqueChars prop_name;
     921         [ -  + ]:        7790 :     if (!gjs_get_string_id(context, id, &prop_name))
     922                 :           0 :         return false;
     923         [ +  + ]:        7790 :     if (!prop_name) {
     924                 :        3576 :         *resolved = false;
     925                 :        3576 :         return true;  // not resolved, but no error
     926                 :             :     }
     927                 :             : 
     928         [ -  + ]:        4214 :     if (!uncached_resolve(context, obj, id, prop_name.get(), resolved))
     929                 :           0 :         return false;
     930                 :             : 
     931   [ +  +  -  +  :        4214 :     if (!*resolved && !m_unresolvable_cache.putNew(id)) {
                   -  + ]
     932                 :           0 :         JS_ReportOutOfMemory(context);
     933                 :           0 :         return false;
     934                 :             :     }
     935                 :             : 
     936                 :        4214 :     return true;
     937                 :        7790 : }
     938                 :             : 
     939                 :        4214 : bool ObjectPrototype::uncached_resolve(JSContext* context, JS::HandleObject obj,
     940                 :             :                                        JS::HandleId id, const char* name,
     941                 :             :                                        bool* resolved) {
     942                 :             :     // If we have no GIRepository information (we're a JS GObject subclass or an
     943                 :             :     // internal non-introspected class such as GLocalFile), we need to look at
     944                 :             :     // exposing interfaces. Look up our interfaces through GType data, and then
     945                 :             :     // hope that *those* are introspectable.
     946         [ +  + ]:        4214 :     if (!info())
     947                 :         356 :         return resolve_no_info(context, obj, id, resolved, name,
     948                 :         356 :                                ConsiderMethodsAndProperties);
     949                 :             : 
     950   [ -  +  +  +  :        3858 :     if (g_str_has_prefix(name, "vfunc_")) {
                   +  + ]
     951                 :             :         /* The only time we find a vfunc info is when we're the base
     952                 :             :          * class that defined the vfunc. If we let regular prototype
     953                 :             :          * chaining resolve this, we'd have the implementation for the base's
     954                 :             :          * vfunc on the base class, without any other "real" implementations
     955                 :             :          * in the way. If we want to expose a "real" vfunc implementation,
     956                 :             :          * we need to go down to the parent infos and look at their VFuncInfos.
     957                 :             :          *
     958                 :             :          * This is good, but it's memory-hungry -- we would define every
     959                 :             :          * possible vfunc on every possible object, even if it's the same
     960                 :             :          * "real" vfunc underneath. Instead, only expose vfuncs that are
     961                 :             :          * different from their parent, and let prototype chaining do the
     962                 :             :          * rest.
     963                 :             :          */
     964                 :             : 
     965                 :          18 :         const char *name_without_vfunc_ = &(name[6]);  /* lifetime tied to name */
     966                 :             :         bool defined_by_parent;
     967                 :             :         GjsAutoVFuncInfo vfunc = find_vfunc_on_parents(
     968                 :          18 :             m_info, name_without_vfunc_, &defined_by_parent);
     969         [ +  + ]:          18 :         if (vfunc) {
     970                 :             :             /* In the event that the vfunc is unchanged, let regular
     971                 :             :              * prototypal inheritance take over. */
     972   [ -  +  -  -  :           1 :             if (defined_by_parent && is_vfunc_unchanged(vfunc)) {
                   -  + ]
     973                 :           0 :                 *resolved = false;
     974                 :           0 :                 return true;
     975                 :             :             }
     976                 :             : 
     977         [ -  + ]:           1 :             if (!gjs_define_function(context, obj, m_gtype, vfunc))
     978                 :           0 :                 return false;
     979                 :             : 
     980                 :           1 :             *resolved = true;
     981                 :           1 :             return true;
     982                 :             :         }
     983                 :             : 
     984                 :             :         /* If the vfunc wasn't found, fall through, back to normal
     985                 :             :          * method resolution. */
     986         [ +  + ]:          18 :     }
     987                 :             : 
     988         [ +  + ]:        3857 :     if (auto const& canonical_name = get_gobject_property_name(m_info, name)) {
     989                 :         242 :         GjsAutoTypeClass<GObjectClass> gobj_class{m_gtype};
     990         [ +  - ]:         242 :         if (GParamSpec* pspec =
     991                 :         242 :                 g_object_class_find_property(gobj_class, canonical_name))
     992                 :         242 :             return lazy_define_gobject_property(context, obj, id, pspec,
     993                 :         242 :                                                 resolved, name);
     994   [ -  +  +  + ]:        4099 :     }
     995                 :             : 
     996                 :        3615 :     GjsAutoFieldInfo field_info = lookup_field_info(m_info, name);
     997         [ +  + ]:        3615 :     if (field_info) {
     998                 :           5 :         bool found = false;
     999         [ -  + ]:           5 :         if (!JS_AlreadyHasOwnPropertyById(context, obj, id, &found))
    1000                 :           0 :             return false;
    1001         [ -  + ]:           5 :         if (found) {
    1002                 :           0 :             *resolved = false;
    1003                 :           0 :             return true;
    1004                 :             :         }
    1005                 :             : 
    1006                 :           5 :         debug_jsprop("Defining lazy GObject field", id, obj);
    1007                 :             : 
    1008                 :           5 :         unsigned flags = GJS_MODULE_PROP_FLAGS;
    1009         [ +  - ]:           5 :         if (!(g_field_info_get_flags(field_info) & GI_FIELD_IS_WRITABLE))
    1010                 :           5 :             flags |= JSPROP_READONLY;
    1011                 :             : 
    1012                 :           5 :         JS::RootedString key(context, id.toString());
    1013         [ -  + ]:           5 :         if (!m_field_cache.putNew(key, field_info.release())) {
    1014                 :           0 :             JS_ReportOutOfMemory(context);
    1015                 :           0 :             return false;
    1016                 :             :         }
    1017                 :             : 
    1018                 :           5 :         JS::RootedValue private_id(context, JS::StringValue(key));
    1019         [ -  + ]:           5 :         if (!gjs_define_property_dynamic(
    1020                 :             :                 context, obj, name, id, "gobject_field",
    1021                 :             :                 &ObjectBase::field_getter, &ObjectBase::field_setter,
    1022                 :             :                 private_id, flags))
    1023                 :           0 :             return false;
    1024                 :             : 
    1025                 :           5 :         *resolved = true;
    1026                 :           5 :         return true;
    1027                 :           5 :     }
    1028                 :             : 
    1029                 :             :     /* find_method does not look at methods on parent classes,
    1030                 :             :      * we rely on javascript to walk up the __proto__ chain
    1031                 :             :      * and find those and define them in the right prototype.
    1032                 :             :      *
    1033                 :             :      * Note that if it isn't a method on the object, since JS
    1034                 :             :      * lacks multiple inheritance, we're sticking the iface
    1035                 :             :      * methods in the object prototype, which means there are many
    1036                 :             :      * copies of the iface methods (one per object class node that
    1037                 :             :      * introduces the iface)
    1038                 :             :      */
    1039                 :             : 
    1040                 :        3610 :     GjsAutoBaseInfo implementor_info;
    1041                 :             :     GjsAutoFunctionInfo method_info =
    1042                 :             :         g_object_info_find_method_using_interfaces(m_info, name,
    1043                 :        3610 :                                                    implementor_info.out());
    1044                 :             : 
    1045                 :             :     /**
    1046                 :             :      * Search through any interfaces implemented by the GType;
    1047                 :             :      * See https://bugzilla.gnome.org/show_bug.cgi?id=632922
    1048                 :             :      * for background on why we need to do this.
    1049                 :             :      */
    1050         [ +  + ]:        3610 :     if (!method_info)
    1051                 :        1816 :         return resolve_no_info(context, obj, id, resolved, name,
    1052                 :        1816 :                                ConsiderOnlyMethods);
    1053                 :             : 
    1054                 :             : #if GJS_VERBOSE_ENABLE_GI_USAGE
    1055                 :             :     _gjs_log_info_usage(method_info);
    1056                 :             : #endif
    1057                 :             : 
    1058         [ +  - ]:        1794 :     if (g_function_info_get_flags (method_info) & GI_FUNCTION_IS_METHOD) {
    1059                 :        1794 :         gjs_debug(GJS_DEBUG_GOBJECT,
    1060                 :             :                   "Defining method %s in prototype for %s (%s.%s)",
    1061                 :             :                   method_info.name(), type_name(), ns(), this->name());
    1062         [ +  + ]:        1794 :         if (GI_IS_INTERFACE_INFO(implementor_info)) {
    1063                 :          77 :             bool found = false;
    1064         [ -  + ]:          77 :             if (!resolve_on_interface_prototype(context, implementor_info, id,
    1065                 :             :                                                 obj, &found))
    1066                 :           0 :                 return false;
    1067                 :             : 
    1068                 :             :             // If the method was not found fallback to defining the function
    1069                 :             :             // from type info...
    1070   [ -  +  -  -  :          77 :             if (!found &&
                   -  + ]
    1071                 :           0 :                 !gjs_define_function(context, obj, m_gtype, method_info)) {
    1072                 :           0 :                 return false;
    1073                 :             :             }
    1074         [ -  + ]:        1717 :         } else if (!gjs_define_function(context, obj, m_gtype, method_info)) {
    1075                 :           0 :             return false;
    1076                 :             :         }
    1077                 :             : 
    1078                 :        1794 :         *resolved = true; /* we defined the prop in obj */
    1079                 :             :     }
    1080                 :             : 
    1081                 :        1794 :     return true;
    1082                 :        3615 : }
    1083                 :             : 
    1084                 :          22 : bool ObjectPrototype::new_enumerate_impl(JSContext* cx, JS::HandleObject,
    1085                 :             :                                          JS::MutableHandleIdVector properties,
    1086                 :             :                                          bool only_enumerable
    1087                 :             :                                          [[maybe_unused]]) {
    1088                 :             :     unsigned n_interfaces;
    1089                 :          22 :     GType* interfaces = g_type_interfaces(gtype(), &n_interfaces);
    1090                 :             : 
    1091         [ -  + ]:          22 :     for (unsigned k = 0; k < n_interfaces; k++) {
    1092                 :             :         GjsAutoInterfaceInfo iface_info =
    1093                 :           0 :             g_irepository_find_by_gtype(nullptr, interfaces[k]);
    1094                 :             : 
    1095         [ #  # ]:           0 :         if (!iface_info) {
    1096                 :           0 :             continue;
    1097                 :             :         }
    1098                 :             : 
    1099                 :           0 :         int n_methods = g_interface_info_get_n_methods(iface_info);
    1100                 :           0 :         int n_properties = g_interface_info_get_n_properties(iface_info);
    1101         [ #  # ]:           0 :         if (!properties.reserve(properties.length() + n_methods +
    1102                 :           0 :                                 n_properties)) {
    1103                 :           0 :             JS_ReportOutOfMemory(cx);
    1104                 :           0 :             return false;
    1105                 :             :         }
    1106                 :             : 
    1107                 :             :         // Methods
    1108         [ #  # ]:           0 :         for (int i = 0; i < n_methods; i++) {
    1109                 :             :             GjsAutoFunctionInfo meth_info =
    1110                 :           0 :                 g_interface_info_get_method(iface_info, i);
    1111                 :           0 :             GIFunctionInfoFlags flags = g_function_info_get_flags(meth_info);
    1112                 :             : 
    1113         [ #  # ]:           0 :             if (flags & GI_FUNCTION_IS_METHOD) {
    1114                 :           0 :                 const char* name = meth_info.name();
    1115                 :           0 :                 jsid id = gjs_intern_string_to_id(cx, name);
    1116         [ #  # ]:           0 :                 if (id.isVoid())
    1117                 :           0 :                     return false;
    1118                 :           0 :                 properties.infallibleAppend(id);
    1119                 :             :             }
    1120         [ #  # ]:           0 :         }
    1121                 :             : 
    1122                 :             :         // Properties
    1123         [ #  # ]:           0 :         for (int i = 0; i < n_properties; i++) {
    1124                 :             :             GjsAutoPropertyInfo prop_info =
    1125                 :           0 :                 g_interface_info_get_property(iface_info, i);
    1126                 :             : 
    1127                 :           0 :             GjsAutoChar js_name = gjs_hyphen_to_underscore(prop_info.name());
    1128                 :             : 
    1129                 :           0 :             jsid id = gjs_intern_string_to_id(cx, js_name);
    1130         [ #  # ]:           0 :             if (id.isVoid())
    1131                 :           0 :                 return false;
    1132                 :           0 :             properties.infallibleAppend(id);
    1133   [ #  #  #  # ]:           0 :         }
    1134      [ #  #  # ]:           0 :     }
    1135                 :             : 
    1136                 :          22 :     g_free(interfaces);
    1137                 :             : 
    1138         [ +  - ]:          22 :     if (info()) {
    1139                 :          22 :         int n_methods = g_object_info_get_n_methods(info());
    1140                 :          22 :         int n_properties = g_object_info_get_n_properties(info());
    1141         [ -  + ]:          44 :         if (!properties.reserve(properties.length() + n_methods +
    1142                 :          22 :                                 n_properties)) {
    1143                 :           0 :             JS_ReportOutOfMemory(cx);
    1144                 :           0 :             return false;
    1145                 :             :         }
    1146                 :             : 
    1147                 :             :         // Methods
    1148         [ +  + ]:        1078 :         for (int i = 0; i < n_methods; i++) {
    1149                 :        1056 :             GjsAutoFunctionInfo meth_info = g_object_info_get_method(info(), i);
    1150                 :        1056 :             GIFunctionInfoFlags flags = g_function_info_get_flags(meth_info);
    1151                 :             : 
    1152         [ +  + ]:        1056 :             if (flags & GI_FUNCTION_IS_METHOD) {
    1153                 :         858 :                 const char* name = meth_info.name();
    1154                 :         858 :                 jsid id = gjs_intern_string_to_id(cx, name);
    1155         [ -  + ]:         858 :                 if (id.isVoid())
    1156                 :           0 :                     return false;
    1157                 :         858 :                 properties.infallibleAppend(id);
    1158                 :             :             }
    1159         [ +  - ]:        1056 :         }
    1160                 :             : 
    1161                 :             :         // Properties
    1162         [ +  + ]:         176 :         for (int i = 0; i < n_properties; i++) {
    1163                 :             :             GjsAutoPropertyInfo prop_info =
    1164                 :         154 :                 g_object_info_get_property(info(), i);
    1165                 :             : 
    1166                 :         154 :             GjsAutoChar js_name = gjs_hyphen_to_underscore(prop_info.name());
    1167                 :         154 :             jsid id = gjs_intern_string_to_id(cx, js_name);
    1168         [ -  + ]:         154 :             if (id.isVoid())
    1169                 :           0 :                 return false;
    1170                 :         154 :             properties.infallibleAppend(id);
    1171   [ +  -  +  - ]:         154 :         }
    1172                 :             :     }
    1173                 :             : 
    1174                 :          22 :     return true;
    1175                 :             : }
    1176                 :             : 
    1177                 :             : /* Set properties from args to constructor (args[0] is supposed to be
    1178                 :             :  * a hash) */
    1179                 :         262 : bool ObjectPrototype::props_to_g_parameters(
    1180                 :             :     JSContext* context, GjsAutoTypeClass<GObjectClass> const& object_class,
    1181                 :             :     JS::HandleObject props, std::vector<const char*>* names,
    1182                 :             :     AutoGValueVector* values) {
    1183                 :             :     size_t ix, length;
    1184                 :         262 :     JS::RootedId prop_id(context);
    1185                 :         262 :     JS::RootedValue value(context);
    1186                 :         262 :     JS::Rooted<JS::IdVector> ids(context, context);
    1187                 :         262 :     std::unordered_set<GParamSpec*> visited_params;
    1188         [ -  + ]:         262 :     if (!JS_Enumerate(context, props, &ids)) {
    1189                 :           0 :         gjs_throw(context, "Failed to create property iterator for object props hash");
    1190                 :           0 :         return false;
    1191                 :             :     }
    1192                 :             : 
    1193                 :         262 :     values->reserve(ids.length());
    1194         [ +  + ]:         858 :     for (ix = 0, length = ids.length(); ix < length; ix++) {
    1195                 :             :         /* ids[ix] is reachable because props is rooted, but require_property
    1196                 :             :          * doesn't know that */
    1197                 :         605 :         prop_id = ids[ix];
    1198                 :             : 
    1199         [ -  + ]:         605 :         if (!prop_id.isString())
    1200                 :           0 :             return gjs_wrapper_throw_nonexistent_field(
    1201                 :           0 :                 context, m_gtype, gjs_debug_id(prop_id).c_str());
    1202                 :             : 
    1203                 :         605 :         JS::RootedString js_prop_name(context, prop_id.toString());
    1204                 :             :         GParamSpec* param_spec =
    1205                 :         605 :             find_param_spec_from_id(context, object_class, js_prop_name);
    1206         [ +  + ]:         605 :         if (!param_spec)
    1207                 :           2 :             return false;
    1208                 :             : 
    1209         [ -  + ]:         603 :         if (visited_params.find(param_spec) != visited_params.end())
    1210                 :           0 :             continue;
    1211                 :         603 :         visited_params.insert(param_spec);
    1212                 :             : 
    1213         [ -  + ]:         603 :         if (!JS_GetPropertyById(context, props, prop_id, &value))
    1214                 :           0 :             return false;
    1215         [ +  + ]:         603 :         if (value.isUndefined()) {
    1216                 :           1 :             gjs_throw(context, "Invalid value 'undefined' for property %s in "
    1217                 :             :                       "object initializer.", param_spec->name);
    1218                 :           1 :             return false;
    1219                 :             :         }
    1220                 :             : 
    1221         [ -  + ]:         602 :         if (!(param_spec->flags & G_PARAM_WRITABLE))
    1222                 :           0 :             return gjs_wrapper_throw_readonly_field(context, m_gtype,
    1223                 :           0 :                                                     param_spec->name);
    1224                 :             :             /* prevent setting the prop even in JS */
    1225                 :             : 
    1226                 :             :         Gjs::AutoGValue& gvalue =
    1227                 :         602 :             values->emplace_back(G_PARAM_SPEC_VALUE_TYPE(param_spec));
    1228         [ +  + ]:         602 :         if (!gjs_value_to_g_value(context, value, &gvalue))
    1229                 :           6 :             return false;
    1230                 :             : 
    1231                 :         596 :         names->push_back(param_spec->name);  // owned by GParamSpec
    1232      [ +  +  - ]:         605 :     }
    1233                 :             : 
    1234                 :         253 :     return true;
    1235                 :         262 : }
    1236                 :             : 
    1237                 :         157 : void ObjectInstance::wrapped_gobj_dispose_notify(
    1238                 :             :     void* data, GObject* where_the_object_was GJS_USED_VERBOSE_LIFECYCLE) {
    1239                 :         157 :     auto *priv = static_cast<ObjectInstance *>(data);
    1240                 :         157 :     priv->gobj_dispose_notify();
    1241                 :             :     gjs_debug_lifecycle(GJS_DEBUG_GOBJECT, "Wrapped GObject %p disposed",
    1242                 :             :                         where_the_object_was);
    1243                 :         157 : }
    1244                 :             : 
    1245                 :         157 : void ObjectInstance::track_gobject_finalization() {
    1246                 :         157 :     auto quark = ObjectBase::disposed_quark();
    1247                 :         157 :     g_object_steal_qdata(m_ptr, quark);
    1248                 :         157 :     g_object_set_qdata_full(m_ptr, quark, this, [](void* data) {
    1249                 :          18 :         auto* self = static_cast<ObjectInstance*>(data);
    1250                 :          18 :         self->m_gobj_finalized = true;
    1251                 :             :         gjs_debug_lifecycle(GJS_DEBUG_GOBJECT, "Wrapped GObject %p finalized",
    1252                 :             :                             self->m_ptr.get());
    1253                 :          18 :     });
    1254                 :         157 : }
    1255                 :             : 
    1256                 :         162 : void ObjectInstance::ignore_gobject_finalization() {
    1257                 :         162 :     auto quark = ObjectBase::disposed_quark();
    1258         [ +  + ]:         162 :     if (g_object_get_qdata(m_ptr, quark) == this) {
    1259                 :         139 :         g_object_steal_qdata(m_ptr, quark);
    1260                 :         139 :         g_object_set_qdata(m_ptr, quark, gjs_int_to_pointer(DISPOSED_OBJECT));
    1261                 :             :     }
    1262                 :         162 : }
    1263                 :             : 
    1264                 :             : void
    1265                 :         157 : ObjectInstance::gobj_dispose_notify(void)
    1266                 :             : {
    1267                 :         157 :     m_gobj_disposed = true;
    1268                 :             : 
    1269                 :         157 :     unset_object_qdata();
    1270                 :         157 :     track_gobject_finalization();
    1271                 :             : 
    1272         [ +  + ]:         157 :     if (m_uses_toggle_ref) {
    1273                 :          70 :         g_object_ref(m_ptr.get());
    1274                 :          70 :         g_object_remove_toggle_ref(m_ptr, wrapped_gobj_toggle_notify, this);
    1275                 :          70 :         ToggleQueue::get_default()->cancel(this);
    1276                 :          70 :         wrapped_gobj_toggle_notify(this, m_ptr, TRUE);
    1277                 :          70 :         m_uses_toggle_ref = false;
    1278                 :             :     }
    1279                 :             : 
    1280         [ +  + ]:         157 :     if (GjsContextPrivate::from_current_context()->is_owner_thread())
    1281                 :         154 :         discard_wrapper();
    1282                 :         157 : }
    1283                 :             : 
    1284                 :         475 : void ObjectInstance::remove_wrapped_gobjects_if(
    1285                 :             :     const ObjectInstance::Predicate& predicate,
    1286                 :             :     const ObjectInstance::Action& action) {
    1287                 :             :     // Note: remove_if() does not actually remove elements, just reorders them
    1288                 :             :     // and returns a start iterator of elements to remove
    1289                 :         950 :     s_wrapped_gobject_list.erase(
    1290                 :         475 :         std::remove_if(s_wrapped_gobject_list.begin(),
    1291                 :             :                        s_wrapped_gobject_list.end(),
    1292                 :         950 :                        ([predicate, action](ObjectInstance* link) {
    1293         [ +  + ]:        2332 :                            if (predicate(link)) {
    1294                 :        1237 :                                action(link);
    1295                 :        1237 :                                return true;
    1296                 :             :                            }
    1297                 :        1095 :                            return false;
    1298                 :             :                        })),
    1299                 :         475 :         s_wrapped_gobject_list.end());
    1300                 :         475 : }
    1301                 :             : 
    1302                 :             : /*
    1303                 :             :  * ObjectInstance::context_dispose_notify:
    1304                 :             :  *
    1305                 :             :  * Callback called when the #GjsContext is disposed. It just calls
    1306                 :             :  * handle_context_dispose() on every ObjectInstance.
    1307                 :             :  */
    1308                 :         239 : void ObjectInstance::context_dispose_notify(void*, GObject* where_the_object_was
    1309                 :             :                                             [[maybe_unused]]) {
    1310                 :         239 :     std::for_each(s_wrapped_gobject_list.begin(), s_wrapped_gobject_list.end(),
    1311                 :             :         std::mem_fn(&ObjectInstance::handle_context_dispose));
    1312                 :         239 : }
    1313                 :             : 
    1314                 :             : /*
    1315                 :             :  * ObjectInstance::handle_context_dispose:
    1316                 :             :  *
    1317                 :             :  * Called on each existing ObjectInstance when the #GjsContext is disposed.
    1318                 :             :  */
    1319                 :        1033 : void ObjectInstance::handle_context_dispose(void) {
    1320         [ +  + ]:        1033 :     if (wrapper_is_rooted()) {
    1321                 :         140 :         debug_lifecycle("Was rooted, but unrooting due to GjsContext dispose");
    1322                 :         140 :         discard_wrapper();
    1323                 :             :     }
    1324                 :        1033 : }
    1325                 :             : 
    1326                 :             : void
    1327                 :        1604 : ObjectInstance::toggle_down(void)
    1328                 :             : {
    1329                 :        1604 :     debug_lifecycle("Toggle notify DOWN");
    1330                 :             : 
    1331                 :             :     /* Change to weak ref so the wrapper-wrappee pair can be
    1332                 :             :      * collected by the GC
    1333                 :             :      */
    1334         [ +  + ]:        1604 :     if (wrapper_is_rooted()) {
    1335                 :        1466 :         debug_lifecycle("Unrooting wrapper");
    1336                 :        1466 :         GjsContextPrivate* gjs = GjsContextPrivate::from_current_context();
    1337                 :        1466 :         switch_to_unrooted(gjs->context());
    1338                 :             : 
    1339                 :             :         /* During a GC, the collector asks each object which other
    1340                 :             :          * objects that it wants to hold on to so if there's an entire
    1341                 :             :          * section of the heap graph that's not connected to anything
    1342                 :             :          * else, and not reachable from the root set, then it can be
    1343                 :             :          * trashed all at once.
    1344                 :             :          *
    1345                 :             :          * GObjects, however, don't work like that, there's only a
    1346                 :             :          * reference count but no notion of who owns the reference so,
    1347                 :             :          * a JS object that's wrapping a GObject is unconditionally held
    1348                 :             :          * alive as long as the GObject has >1 references.
    1349                 :             :          *
    1350                 :             :          * Since we cannot know how many more wrapped GObjects are going
    1351                 :             :          * be marked for garbage collection after the owner is destroyed,
    1352                 :             :          * always queue a garbage collection when a toggle reference goes
    1353                 :             :          * down.
    1354                 :             :          */
    1355         [ +  - ]:        1466 :         if (!gjs->destroying())
    1356                 :        1466 :             gjs->schedule_gc();
    1357                 :             :     }
    1358                 :        1604 : }
    1359                 :             : 
    1360                 :             : void
    1361                 :         877 : ObjectInstance::toggle_up(void)
    1362                 :             : {
    1363   [ +  -  +  +  :         877 :     if (G_UNLIKELY(!m_ptr || m_gobj_disposed || m_gobj_finalized)) {
             -  +  +  + ]
    1364                 :           1 :         if (m_ptr) {
    1365                 :             :             gjs_debug_lifecycle(
    1366                 :             :                 GJS_DEBUG_GOBJECT,
    1367                 :             :                 "Avoid to toggle up a wrapper for a %s object: %p (%s)",
    1368                 :             :                 m_gobj_finalized ? "finalized" : "disposed", m_ptr.get(),
    1369                 :             :                 g_type_name(gtype()));
    1370                 :             :         } else {
    1371                 :             :             gjs_debug_lifecycle(
    1372                 :             :                 GJS_DEBUG_GOBJECT,
    1373                 :             :                 "Avoid to toggle up a wrapper for a released %s object (%p)",
    1374                 :             :                 g_type_name(gtype()), this);
    1375                 :             :         }
    1376                 :           1 :         return;
    1377                 :             :     }
    1378                 :             : 
    1379                 :             :     /* We need to root the JSObject associated with the passed in GObject so it
    1380                 :             :      * doesn't get garbage collected (and lose any associated javascript state
    1381                 :             :      * such as custom properties).
    1382                 :             :      */
    1383         [ -  + ]:         876 :     if (!has_wrapper()) /* Object already GC'd */
    1384                 :           0 :         return;
    1385                 :             : 
    1386                 :         876 :     debug_lifecycle("Toggle notify UP");
    1387                 :             : 
    1388                 :             :     /* Change to strong ref so the wrappee keeps the wrapper alive
    1389                 :             :      * in case the wrapper has data in it that the app cares about
    1390                 :             :      */
    1391         [ +  + ]:         876 :     if (!wrapper_is_rooted()) {
    1392                 :             :         // FIXME: thread the context through somehow. Maybe by looking up the
    1393                 :             :         // realm that obj belongs to.
    1394                 :         875 :         debug_lifecycle("Rooting wrapper");
    1395                 :         875 :         auto* cx = GjsContextPrivate::from_current_context()->context();
    1396                 :         875 :         switch_to_rooted(cx);
    1397                 :             :     }
    1398                 :             : }
    1399                 :             : 
    1400                 :           9 : static void toggle_handler(ObjectInstance* self,
    1401                 :             :                            ToggleQueue::Direction direction) {
    1402      [ +  +  - ]:           9 :     switch (direction) {
    1403                 :           4 :         case ToggleQueue::UP:
    1404                 :           4 :             self->toggle_up();
    1405                 :           4 :             break;
    1406                 :           5 :         case ToggleQueue::DOWN:
    1407                 :           5 :             self->toggle_down();
    1408                 :           5 :             break;
    1409                 :           0 :         default:
    1410                 :             :             g_assert_not_reached();
    1411                 :             :     }
    1412                 :           9 : }
    1413                 :             : 
    1414                 :        2529 : void ObjectInstance::wrapped_gobj_toggle_notify(void* instance, GObject*,
    1415                 :             :                                                 gboolean is_last_ref) {
    1416                 :             :     bool is_main_thread;
    1417                 :             :     bool toggle_up_queued, toggle_down_queued;
    1418                 :        2529 :     auto* self = static_cast<ObjectInstance*>(instance);
    1419                 :             : 
    1420                 :        2529 :     GjsContextPrivate* gjs = GjsContextPrivate::from_current_context();
    1421         [ -  + ]:        2529 :     if (gjs->destroying()) {
    1422                 :             :         /* Do nothing here - we're in the process of disassociating
    1423                 :             :          * the objects.
    1424                 :             :          */
    1425                 :           0 :         return;
    1426                 :             :     }
    1427                 :             : 
    1428                 :             :     /* We only want to touch javascript from one thread.
    1429                 :             :      * If we're not in that thread, then we need to defer processing
    1430                 :             :      * to it.
    1431                 :             :      * In case we're toggling up (and thus rooting the JS object) we
    1432                 :             :      * also need to take care if GC is running. The marking side
    1433                 :             :      * of it is taken care by JS::Heap, which we use in GjsMaybeOwned,
    1434                 :             :      * so we're safe. As for sweeping, it is too late: the JS object
    1435                 :             :      * is dead, and attempting to keep it alive would soon crash
    1436                 :             :      * the process. Plus, if we touch the JSAPI from another thread, libmozjs
    1437                 :             :      * aborts in most cases when in debug mode.
    1438                 :             :      * Thus, we drain the toggle queue when GC starts, in order to
    1439                 :             :      * prevent this from happening.
    1440                 :             :      * In practice, a toggle up during JS finalize can only happen
    1441                 :             :      * for temporary refs/unrefs of objects that are garbage anyway,
    1442                 :             :      * because JS code is never invoked while the finalizers run
    1443                 :             :      * and C code needs to clean after itself before it returns
    1444                 :             :      * from dispose()/finalize().
    1445                 :             :      * On the other hand, toggling down is a lot simpler, because
    1446                 :             :      * we're creating more garbage. So we just unroot the object, make it a
    1447                 :             :      * weak pointer, and wait for the next GC cycle.
    1448                 :             :      *
    1449                 :             :      * Note that one would think that toggling up only happens
    1450                 :             :      * in the main thread (because toggling up is the result of
    1451                 :             :      * the JS object, previously visible only to JS code, becoming
    1452                 :             :      * visible to the refcounted C world), but because of weird
    1453                 :             :      * weak singletons like g_bus_get_sync() objects can see toggle-ups
    1454                 :             :      * from different threads too.
    1455                 :             :      */
    1456                 :        2529 :     is_main_thread = gjs->is_owner_thread();
    1457                 :             : 
    1458                 :        2529 :     auto toggle_queue = ToggleQueue::get_default();
    1459                 :        2529 :     std::tie(toggle_down_queued, toggle_up_queued) =
    1460                 :        5058 :         toggle_queue->is_queued(self);
    1461   [ +  +  +  + ]:        2529 :     bool anything_queued = toggle_up_queued || toggle_down_queued;
    1462                 :             : 
    1463         [ +  + ]:        2529 :     if (is_last_ref) {
    1464                 :             :         /* We've transitions from 2 -> 1 references,
    1465                 :             :          * The JSObject is rooted and we need to unroot it so it
    1466                 :             :          * can be garbage collected
    1467                 :             :          */
    1468   [ +  +  +  + ]:        1626 :         if (is_main_thread && !anything_queued) {
    1469                 :        1599 :             self->toggle_down();
    1470                 :             :         } else {
    1471                 :          27 :             toggle_queue->enqueue(self, ToggleQueue::DOWN, toggle_handler);
    1472                 :             :         }
    1473                 :             :     } else {
    1474                 :             :         /* We've transitioned from 1 -> 2 references.
    1475                 :             :          *
    1476                 :             :          * The JSObject associated with the gobject is not rooted,
    1477                 :             :          * but it needs to be. We'll root it.
    1478                 :             :          */
    1479   [ +  +  +  +  :        1783 :         if (is_main_thread && !anything_queued &&
                   +  + ]
    1480         [ +  + ]:         880 :             !JS::RuntimeHeapIsCollecting()) {
    1481                 :         873 :             self->toggle_up();
    1482                 :             :         } else {
    1483                 :          30 :             toggle_queue->enqueue(self, ToggleQueue::UP, toggle_handler);
    1484                 :             :         }
    1485                 :             :     }
    1486                 :        2529 : }
    1487                 :             : 
    1488                 :             : void
    1489                 :        1551 : ObjectInstance::release_native_object(void)
    1490                 :             : {
    1491                 :             :     static GType gdksurface_type = 0;
    1492                 :             : 
    1493                 :        1551 :     discard_wrapper();
    1494                 :             : 
    1495         [ +  + ]:        1551 :     if (m_gobj_finalized) {
    1496                 :          19 :         g_critical(
    1497                 :             :             "Object %p of type %s has been finalized while it was still "
    1498                 :             :             "owned by gjs, this is due to invalid memory management.",
    1499                 :             :             m_ptr.get(), g_type_name(gtype()));
    1500                 :          19 :         m_ptr.release();
    1501                 :          19 :         return;
    1502                 :             :     }
    1503                 :             : 
    1504                 :        1532 :     if (m_ptr)
    1505                 :             :         gjs_debug_lifecycle(GJS_DEBUG_GOBJECT, "Releasing native object %s %p",
    1506                 :             :                             g_type_name(gtype()), m_ptr.get());
    1507                 :             : 
    1508         [ +  + ]:        1532 :     if (m_gobj_disposed)
    1509                 :         162 :         ignore_gobject_finalization();
    1510                 :             : 
    1511   [ +  +  +  - ]:        1532 :     if (m_uses_toggle_ref && !m_gobj_disposed) {
    1512                 :         661 :         g_object_remove_toggle_ref(m_ptr.release(), wrapped_gobj_toggle_notify,
    1513                 :             :                                    this);
    1514                 :         661 :         return;
    1515                 :             :     }
    1516                 :             : 
    1517                 :             :     // Unref the object. Handle any special cases for destruction here
    1518         [ +  + ]:         871 :     if (m_ptr->ref_count == 1) {
    1519                 :             :         // Quickest way to check for GdkSurface if Gdk has been loaded?
    1520                 :             :         // surface_type may be 0 if Gdk not loaded. The type may be a private
    1521                 :             :         // type and not have introspection info.
    1522         [ +  + ]:         794 :         if (!gdksurface_type)
    1523                 :         721 :             gdksurface_type = g_type_from_name("GdkSurface");
    1524   [ +  +  +  -  :         794 :         if (gdksurface_type && g_type_is_a(gtype(), gdksurface_type)) {
             -  +  -  + ]
    1525                 :           0 :             GObject* ptr = m_ptr.release();
    1526                 :             : 
    1527                 :             :             // Workaround for https://gitlab.gnome.org/GNOME/gtk/-/issues/6289
    1528                 :             :             GjsAutoObjectInfo surface_info =
    1529                 :           0 :                 g_irepository_find_by_gtype(nullptr, gdksurface_type);
    1530                 :           0 :             g_assert(surface_info && "Could not find introspected GdkSurface info");
    1531                 :             :             GjsAutoFunctionInfo destroy_func =
    1532                 :           0 :                 g_object_info_find_method(surface_info, "destroy");
    1533                 :             :             GIArgument destroy_args;
    1534                 :           0 :             gjs_arg_set(&destroy_args, ptr);
    1535                 :             :             GIArgument unused_return;
    1536                 :             : 
    1537                 :           0 :             GjsAutoError err;
    1538         [ #  # ]:           0 :             if (!g_function_info_invoke(destroy_func, &destroy_args, 1, nullptr,
    1539                 :             :                                         0, &unused_return, err.out()))
    1540                 :           0 :                 g_critical("Error destroying GdkSurface %p: %s", ptr,
    1541                 :             :                            err->message);
    1542                 :           0 :         }
    1543                 :             :     }
    1544                 :             : 
    1545                 :         871 :     m_ptr = nullptr;
    1546                 :             : }
    1547                 :             : 
    1548                 :             : /* At shutdown, we need to ensure we've cleared the context of any
    1549                 :             :  * pending toggle references.
    1550                 :             :  */
    1551                 :             : void
    1552                 :         720 : gjs_object_clear_toggles(void)
    1553                 :             : {
    1554                 :         720 :     ToggleQueue::get_default()->handle_all_toggles(toggle_handler);
    1555                 :         720 : }
    1556                 :             : 
    1557                 :             : void
    1558                 :         239 : gjs_object_shutdown_toggle_queue(void)
    1559                 :             : {
    1560                 :         239 :     ToggleQueue::get_default()->shutdown();
    1561                 :         239 : }
    1562                 :             : 
    1563                 :             : /*
    1564                 :             :  * ObjectInstance::prepare_shutdown:
    1565                 :             :  *
    1566                 :             :  * Called when the #GjsContext is disposed, in order to release all GC roots of
    1567                 :             :  * JSObjects that are held by GObjects.
    1568                 :             :  */
    1569                 :         239 : void ObjectInstance::prepare_shutdown(void) {
    1570                 :             :     /* We iterate over all of the objects, breaking the JS <-> C
    1571                 :             :      * association.  We avoid the potential recursion implied in:
    1572                 :             :      *   toggle ref removal -> gobj dispose -> toggle ref notify
    1573                 :             :      * by emptying the toggle queue earlier in the shutdown sequence. */
    1574                 :         478 :     ObjectInstance::remove_wrapped_gobjects_if(
    1575                 :         478 :         std::mem_fn(&ObjectInstance::wrapper_is_rooted),
    1576                 :         239 :         std::mem_fn(&ObjectInstance::release_native_object));
    1577                 :         239 : }
    1578                 :             : 
    1579                 :        1569 : ObjectInstance::ObjectInstance(ObjectPrototype* prototype,
    1580                 :        1569 :                                JS::HandleObject object)
    1581                 :             :     : GIWrapperInstance(prototype, object),
    1582                 :        1569 :       m_wrapper_finalized(false),
    1583                 :        1569 :       m_gobj_disposed(false),
    1584                 :        1569 :       m_gobj_finalized(false),
    1585                 :        1569 :       m_uses_toggle_ref(false) {
    1586                 :             :     GTypeQuery query;
    1587                 :        1569 :     type_query_dynamic_safe(&query);
    1588         [ +  - ]:        1569 :     if (G_LIKELY(query.type))
    1589                 :        1569 :         JS::AddAssociatedMemory(object, query.instance_size,
    1590                 :             :                                 MemoryUse::GObjectInstanceStruct);
    1591                 :             : 
    1592                 :        1569 :     GJS_INC_COUNTER(object_instance);
    1593                 :        1569 : }
    1594                 :             : 
    1595                 :         670 : ObjectPrototype::ObjectPrototype(GIObjectInfo* info, GType gtype)
    1596                 :         670 :     : GIWrapperPrototype(info, gtype) {
    1597                 :         670 :     g_type_class_ref(gtype);
    1598                 :             : 
    1599                 :         670 :     GJS_INC_COUNTER(object_prototype);
    1600                 :         670 : }
    1601                 :             : 
    1602                 :             : /*
    1603                 :             :  * ObjectInstance::update_heap_wrapper_weak_pointers:
    1604                 :             :  *
    1605                 :             :  * Private callback, called after the JS engine finishes garbage collection, and
    1606                 :             :  * notifies when weak pointers need to be either moved or swept.
    1607                 :             :  */
    1608                 :         236 : void ObjectInstance::update_heap_wrapper_weak_pointers(JSTracer* trc,
    1609                 :             :                                                        JS::Compartment*,
    1610                 :             :                                                        void*) {
    1611                 :             :     gjs_debug_lifecycle(GJS_DEBUG_GOBJECT, "Weak pointer update callback, "
    1612                 :             :                         "%zu wrapped GObject(s) to examine",
    1613                 :             :                         ObjectInstance::num_wrapped_gobjects());
    1614                 :             : 
    1615                 :             :     // Take a lock on the queue till we're done with it, so that we don't
    1616                 :             :     // risk that another thread will queue something else while sweeping
    1617                 :         236 :     auto locked_queue = ToggleQueue::get_default();
    1618                 :             : 
    1619                 :         472 :     ObjectInstance::remove_wrapped_gobjects_if(
    1620                 :         472 :         [&trc](ObjectInstance* instance) -> bool {
    1621                 :        2310 :             return instance->weak_pointer_was_finalized(trc);
    1622                 :             :         },
    1623                 :         236 :         std::mem_fn(&ObjectInstance::disassociate_js_gobject));
    1624                 :             : 
    1625                 :         236 :     s_wrapped_gobject_list.shrink_to_fit();
    1626                 :         236 : }
    1627                 :             : 
    1628                 :        2310 : bool ObjectInstance::weak_pointer_was_finalized(JSTracer* trc) {
    1629   [ +  +  +  +  :        2310 :     if (has_wrapper() && !wrapper_is_rooted()) {
                   +  + ]
    1630                 :             :         bool toggle_down_queued, toggle_up_queued;
    1631                 :             : 
    1632                 :        1546 :         auto toggle_queue = ToggleQueue::get_default();
    1633                 :        1546 :         std::tie(toggle_down_queued, toggle_up_queued) =
    1634                 :        3092 :             toggle_queue->is_queued(this);
    1635                 :             : 
    1636   [ +  -  +  + ]:        1546 :         if (!toggle_down_queued && toggle_up_queued)
    1637                 :           2 :             return false;
    1638                 :             : 
    1639         [ +  + ]:        1544 :         if (!update_after_gc(trc))
    1640                 :         307 :             return false;
    1641                 :             : 
    1642         [ -  + ]:        1237 :         if (toggle_down_queued)
    1643                 :           0 :             toggle_queue->cancel(this);
    1644                 :             : 
    1645                 :             :         /* Ouch, the JS object is dead already. Disassociate the
    1646                 :             :          * GObject and hope the GObject dies too. (Remove it from
    1647                 :             :          * the weak pointer list first, since the disassociation
    1648                 :             :          * may also cause it to be erased.)
    1649                 :             :          */
    1650                 :        1237 :         debug_lifecycle("Found GObject weak pointer whose JS wrapper is about "
    1651                 :             :                         "to be finalized");
    1652                 :        1237 :         return true;
    1653                 :        1546 :     }
    1654                 :         764 :     return false;
    1655                 :             : }
    1656                 :             : 
    1657                 :             : /*
    1658                 :             :  * ObjectInstance::ensure_weak_pointer_callback:
    1659                 :             :  *
    1660                 :             :  * Private method called when adding a weak pointer for the first time.
    1661                 :             :  */
    1662                 :        1552 : void ObjectInstance::ensure_weak_pointer_callback(JSContext* cx) {
    1663         [ +  + ]:        1552 :     if (!s_weak_pointer_callback) {
    1664                 :          29 :         JS_AddWeakPointerCompartmentCallback(
    1665                 :             :             cx, &ObjectInstance::update_heap_wrapper_weak_pointers, nullptr);
    1666                 :          29 :         s_weak_pointer_callback = true;
    1667                 :             :     }
    1668                 :        1552 : }
    1669                 :             : 
    1670                 :             : void
    1671                 :        1552 : ObjectInstance::associate_js_gobject(JSContext       *context,
    1672                 :             :                                      JS::HandleObject object,
    1673                 :             :                                      GObject         *gobj)
    1674                 :             : {
    1675                 :        1552 :     g_assert(!wrapper_is_rooted());
    1676                 :             : 
    1677                 :        1552 :     m_uses_toggle_ref = false;
    1678                 :        1552 :     m_ptr = gobj;
    1679                 :        1552 :     set_object_qdata();
    1680                 :        1552 :     m_wrapper = object;
    1681                 :        1552 :     m_gobj_disposed = !!g_object_get_qdata(gobj, ObjectBase::disposed_quark());
    1682                 :             : 
    1683                 :        1552 :     ensure_weak_pointer_callback(context);
    1684                 :        1552 :     link();
    1685                 :             : 
    1686         [ +  + ]:        1552 :     if (!G_UNLIKELY(m_gobj_disposed))
    1687                 :        1528 :         g_object_weak_ref(gobj, wrapped_gobj_dispose_notify, this);
    1688                 :        1552 : }
    1689                 :             : 
    1690                 :        1494 : void ObjectInstance::ensure_uses_toggle_ref(JSContext* cx) {
    1691         [ +  + ]:        1494 :     if (m_uses_toggle_ref)
    1692                 :         760 :         return;
    1693                 :             : 
    1694         [ +  + ]:         734 :     if (!check_gobject_disposed_or_finalized("add toggle reference on"))
    1695                 :           2 :         return;
    1696                 :             : 
    1697                 :         732 :     debug_lifecycle("Switching object instance to toggle ref");
    1698                 :             : 
    1699                 :         732 :     g_assert(!wrapper_is_rooted());
    1700                 :             : 
    1701                 :             :     /* OK, here is where things get complicated. We want the
    1702                 :             :      * wrapped gobj to keep the JSObject* wrapper alive, because
    1703                 :             :      * people might set properties on the JSObject* that they care
    1704                 :             :      * about. Therefore, whenever the refcount on the wrapped gobj
    1705                 :             :      * is >1, i.e. whenever something other than the wrapper is
    1706                 :             :      * referencing the wrapped gobj, the wrapped gobj has a strong
    1707                 :             :      * ref (gc-roots the wrapper). When the refcount on the
    1708                 :             :      * wrapped gobj is 1, then we change to a weak ref to allow
    1709                 :             :      * the wrapper to be garbage collected (and thus unref the
    1710                 :             :      * wrappee).
    1711                 :             :      */
    1712                 :         732 :     m_uses_toggle_ref = true;
    1713                 :         732 :     switch_to_rooted(cx);
    1714                 :         732 :     g_object_add_toggle_ref(m_ptr, wrapped_gobj_toggle_notify, this);
    1715                 :             : 
    1716                 :             :     /* We now have both a ref and a toggle ref, we only want the toggle ref.
    1717                 :             :      * This may immediately remove the GC root we just added, since refcount
    1718                 :             :      * may drop to 1. */
    1719                 :         732 :     g_object_unref(m_ptr);
    1720                 :             : }
    1721                 :             : 
    1722                 :        3472 : static void invalidate_closure_vector(std::vector<GClosure*>* closures,
    1723                 :             :                                       void* data, GClosureNotify notify_func) {
    1724                 :        3472 :     g_assert(closures);
    1725                 :        3472 :     g_assert(notify_func);
    1726                 :             : 
    1727         [ +  + ]:        3744 :     for (auto it = closures->begin(); it != closures->end();) {
    1728                 :             :         // This will also free the closure data, through the closure
    1729                 :             :         // invalidation mechanism, but adding a temporary reference to
    1730                 :             :         // ensure that the closure is still valid when calling invalidation
    1731                 :             :         // notify callbacks
    1732                 :         272 :         GjsAutoGClosure closure(*it, GjsAutoTakeOwnership());
    1733                 :         272 :         it = closures->erase(it);
    1734                 :             : 
    1735                 :             :         // Only call the invalidate notifiers that won't touch this vector
    1736                 :         272 :         g_closure_remove_invalidate_notifier(closure, data, notify_func);
    1737                 :         272 :         g_closure_invalidate(closure);
    1738                 :         272 :     }
    1739                 :             : 
    1740                 :        3472 :     g_assert(closures->empty());
    1741                 :        3472 : }
    1742                 :             : 
    1743                 :             : // Note: m_wrapper (the JS object) may already be null when this is called, if
    1744                 :             : // it was finalized while the GObject was toggled down.
    1745                 :             : void
    1746                 :        1237 : ObjectInstance::disassociate_js_gobject(void)
    1747                 :             : {
    1748                 :             :     bool had_toggle_down, had_toggle_up;
    1749                 :             : 
    1750                 :        1237 :     std::tie(had_toggle_down, had_toggle_up) =
    1751                 :        2474 :         ToggleQueue::get_default()->cancel(this);
    1752   [ -  +  -  - ]:        1237 :     if (had_toggle_up && !had_toggle_down) {
    1753                 :           0 :         g_error(
    1754                 :             :             "JS object wrapper for GObject %p (%s) is being released while "
    1755                 :             :             "toggle references are still pending.",
    1756                 :             :             m_ptr.get(), type_name());
    1757                 :             :     }
    1758                 :             : 
    1759         [ +  + ]:        1237 :     if (!m_gobj_disposed)
    1760                 :        1210 :         g_object_weak_unref(m_ptr.get(), wrapped_gobj_dispose_notify, this);
    1761                 :             : 
    1762         [ +  + ]:        1237 :     if (!m_gobj_finalized) {
    1763                 :             :         /* Fist, remove the wrapper pointer from the wrapped GObject */
    1764                 :        1235 :         unset_object_qdata();
    1765                 :             :     }
    1766                 :             : 
    1767                 :             :     /* Now release all the resources the current wrapper has */
    1768                 :        1237 :     invalidate_closures();
    1769                 :        1237 :     release_native_object();
    1770                 :             : 
    1771                 :             :     /* Mark that a JS object once existed, but it doesn't any more */
    1772                 :        1237 :     m_wrapper_finalized = true;
    1773                 :        1237 : }
    1774                 :             : 
    1775                 :         906 : bool ObjectInstance::init_impl(JSContext* context, const JS::CallArgs& args,
    1776                 :             :                                JS::HandleObject object) {
    1777                 :         906 :     g_assert(gtype() != G_TYPE_NONE);
    1778                 :             : 
    1779   [ +  +  -  + ]:         907 :     if (args.length() > 1 &&
    1780         [ -  + ]:           1 :         !JS::WarnUTF8(context,
    1781                 :             :                       "Too many arguments to the constructor of %s: expected "
    1782                 :             :                       "1, got %u",
    1783                 :             :                       name(), args.length()))
    1784                 :           0 :         return false;
    1785                 :             : 
    1786                 :         906 :     GjsAutoTypeClass<GObjectClass> object_class(gtype());
    1787                 :         906 :     std::vector<const char *> names;
    1788                 :         906 :     AutoGValueVector values;
    1789                 :             : 
    1790   [ +  +  +  +  :         906 :     if (args.length() > 0 && !args[0].isUndefined()) {
                   +  + ]
    1791         [ +  + ]:         264 :         if (!args[0].isObject()) {
    1792                 :           1 :             gjs_throw(context,
    1793                 :             :                       "Argument to the constructor of %s should be a plain JS "
    1794                 :             :                       "object with properties to set",
    1795                 :             :                       name());
    1796                 :          11 :             return false;
    1797                 :             :         }
    1798                 :             : 
    1799                 :         263 :         JS::RootedObject props(context, &args[0].toObject());
    1800         [ +  + ]:         263 :         if (ObjectInstance::typecheck(context, props, nullptr, G_TYPE_NONE,
    1801                 :             :                                       GjsTypecheckNoThrow{})) {
    1802                 :           1 :             gjs_throw(context,
    1803                 :             :                       "Argument to the constructor of %s should be a plain JS "
    1804                 :             :                       "object with properties to set",
    1805                 :             :                       name());
    1806                 :           1 :             return false;
    1807                 :             :         }
    1808         [ +  + ]:         262 :         if (!m_proto->props_to_g_parameters(context, object_class, props,
    1809                 :             :                                             &names, &values))
    1810                 :           9 :             return false;
    1811         [ +  + ]:         263 :     }
    1812                 :             : 
    1813         [ +  + ]:         895 :     if (G_TYPE_IS_ABSTRACT(gtype())) {
    1814                 :           1 :         gjs_throw(context,
    1815                 :             :                   "Cannot instantiate abstract type %s", g_type_name(gtype()));
    1816                 :           1 :         return false;
    1817                 :             :     }
    1818                 :             : 
    1819                 :             :     // Mark this object in the construction stack, it will be popped in
    1820                 :             :     // gjs_object_custom_init() in gi/gobject.cpp.
    1821         [ +  + ]:         894 :     if (is_custom_js_class()) {
    1822                 :         481 :         GjsContextPrivate* gjs = GjsContextPrivate::from_cx(context);
    1823         [ -  + ]:         481 :         if (!gjs->object_init_list().append(object)) {
    1824                 :           0 :             JS_ReportOutOfMemory(context);
    1825                 :           0 :             return false;
    1826                 :             :         }
    1827                 :             :     }
    1828                 :             : 
    1829                 :         894 :     g_assert(names.size() == values.size());
    1830                 :         894 :     GObject* gobj = g_object_new_with_properties(gtype(), values.size(),
    1831                 :         894 :                                                  names.data(), values.data());
    1832                 :             : 
    1833                 :         894 :     ObjectInstance *other_priv = ObjectInstance::for_gobject(gobj);
    1834   [ +  +  +  +  :         894 :     if (other_priv && other_priv->m_wrapper != object.get()) {
                   +  + ]
    1835                 :             :         /* g_object_new_with_properties() returned an object that's already
    1836                 :             :          * tracked by a JS object.
    1837                 :             :          *
    1838                 :             :          * This typically occurs in one of two cases:
    1839                 :             :          * - This object is a singleton like IBus.IBus
    1840                 :             :          * - This object passed itself to JS before g_object_new_* returned
    1841                 :             :          *
    1842                 :             :          * In these cases, return the existing JS wrapper object instead
    1843                 :             :          * of creating a new one.
    1844                 :             :          *
    1845                 :             :          * 'object' has a value that was originally created by
    1846                 :             :          * JS_NewObjectForConstructor in GJS_NATIVE_CONSTRUCTOR_PRELUDE, but
    1847                 :             :          * we're not actually using it, so just let it get collected. Avoiding
    1848                 :             :          * this would require a non-trivial amount of work.
    1849                 :             :          * */
    1850                 :           1 :         bool toggle_ref_added = false;
    1851         [ +  - ]:           1 :         if (!m_uses_toggle_ref) {
    1852                 :           1 :             other_priv->ensure_uses_toggle_ref(context);
    1853                 :           1 :             toggle_ref_added = m_uses_toggle_ref;
    1854                 :             :         }
    1855                 :             : 
    1856                 :           1 :         args.rval().setObject(*other_priv->m_wrapper.get());
    1857                 :             : 
    1858         [ -  + ]:           1 :         if (toggle_ref_added)
    1859         [ #  # ]:           0 :             g_clear_object(&gobj); /* We already own a reference */
    1860                 :           1 :         return true;
    1861                 :             :     }
    1862                 :             : 
    1863   [ -  +  +  -  :        1025 :     if (G_IS_INITIALLY_UNOWNED(gobj) &&
          -  +  +  +  +  
                +  +  + ]
    1864                 :         132 :         !g_object_is_floating(gobj)) {
    1865                 :             :         /* GtkWindow does not return a ref to caller of g_object_new.
    1866                 :             :          * Need a flag in gobject-introspection to tell us this.
    1867                 :             :          */
    1868                 :          75 :         gjs_debug(GJS_DEBUG_GOBJECT,
    1869                 :             :                   "Newly-created object is initially unowned but we did not get the "
    1870                 :             :                   "floating ref, probably GtkWindow, using hacky workaround");
    1871                 :          75 :         g_object_ref(gobj);
    1872         [ +  + ]:         818 :     } else if (g_object_is_floating(gobj)) {
    1873                 :          57 :         g_object_ref_sink(gobj);
    1874                 :             :     } else {
    1875                 :             :         /* we should already have a ref */
    1876                 :             :     }
    1877                 :             : 
    1878         [ +  + ]:         893 :     if (!m_ptr)
    1879                 :         412 :         associate_js_gobject(context, object, gobj);
    1880                 :             : 
    1881                 :             :     TRACE(GJS_OBJECT_WRAPPER_NEW(this, m_ptr, ns(), name()));
    1882                 :             : 
    1883                 :         893 :     args.rval().setObject(*object);
    1884                 :         893 :     return true;
    1885                 :         906 : }
    1886                 :             : 
    1887                 :             : // See GIWrapperBase::constructor()
    1888                 :         910 : bool ObjectInstance::constructor_impl(JSContext* context,
    1889                 :             :                                       JS::HandleObject object,
    1890                 :             :                                       const JS::CallArgs& argv) {
    1891                 :         910 :     JS::RootedValue initer(context);
    1892                 :         910 :     GjsContextPrivate* gjs = GjsContextPrivate::from_cx(context);
    1893                 :         910 :     const auto& new_target = argv.newTarget();
    1894                 :             :     bool has_gtype;
    1895                 :             : 
    1896                 :         910 :     g_assert(new_target.isObject() && "new.target needs to be an object");
    1897                 :         910 :     JS::RootedObject rooted_target(context, &new_target.toObject());
    1898         [ -  + ]:         910 :     if (!JS_HasOwnPropertyById(context, rooted_target, gjs->atoms().gtype(),
    1899                 :             :                                &has_gtype))
    1900                 :           0 :         return false;
    1901                 :             : 
    1902         [ -  + ]:         910 :     if (!has_gtype) {
    1903                 :           0 :         gjs_throw(context,
    1904                 :             :                   "Tried to construct an object without a GType; are "
    1905                 :             :                   "you using GObject.registerClass() when inheriting "
    1906                 :             :                   "from a GObject type?");
    1907                 :           0 :         return false;
    1908                 :             :     }
    1909                 :             : 
    1910                 :        1820 :     return gjs_object_require_property(context, object, "GObject instance",
    1911   [ +  -  +  + ]:        2730 :                                        gjs->atoms().init(), &initer) &&
    1912                 :        1820 :            gjs->call_function(object, initer, argv, argv.rval());
    1913                 :         910 : }
    1914                 :             : 
    1915                 :         256 : void ObjectInstance::trace_impl(JSTracer* tracer) {
    1916         [ +  + ]:         332 :     for (GClosure *closure : m_closures)
    1917                 :          76 :         Gjs::Closure::for_gclosure(closure)->trace(tracer);
    1918                 :         256 : }
    1919                 :             : 
    1920                 :        2267 : void ObjectPrototype::trace_impl(JSTracer* tracer) {
    1921                 :        2267 :     m_field_cache.trace(tracer);
    1922                 :        2267 :     m_unresolvable_cache.trace(tracer);
    1923         [ +  + ]:        2367 :     for (GClosure* closure : m_vfuncs)
    1924                 :         100 :         Gjs::Closure::for_gclosure(closure)->trace(tracer);
    1925                 :        2267 : }
    1926                 :             : 
    1927                 :        1568 : void ObjectInstance::finalize_impl(JS::GCContext* gcx, JSObject* obj) {
    1928                 :             :     GTypeQuery query;
    1929                 :        1568 :     type_query_dynamic_safe(&query);
    1930         [ +  - ]:        1568 :     if (G_LIKELY(query.type))
    1931                 :        1568 :         JS::RemoveAssociatedMemory(obj, query.instance_size,
    1932                 :             :                                    MemoryUse::GObjectInstanceStruct);
    1933                 :             : 
    1934                 :        1568 :     GIWrapperInstance::finalize_impl(gcx, obj);
    1935                 :        1568 : }
    1936                 :             : 
    1937                 :        1568 : ObjectInstance::~ObjectInstance() {
    1938                 :             :     TRACE(GJS_OBJECT_WRAPPER_FINALIZE(this, m_ptr, ns(), name()));
    1939                 :             : 
    1940                 :        1568 :     invalidate_closures();
    1941                 :             : 
    1942                 :             :     // Do not keep the queue locked here, as we may want to leave the other
    1943                 :             :     // threads to queue toggle events till we're owning the GObject so that
    1944                 :             :     // eventually (once the toggle reference is finally removed) we can be
    1945                 :             :     // sure that no other toggle event will target this (soon dead) wrapper.
    1946                 :             :     bool had_toggle_up;
    1947                 :             :     bool had_toggle_down;
    1948                 :        1568 :     std::tie(had_toggle_down, had_toggle_up) =
    1949                 :        3136 :         ToggleQueue::get_default()->cancel(this);
    1950                 :             : 
    1951                 :             :     /* GObject is not already freed */
    1952         [ +  + ]:        1568 :     if (m_ptr) {
    1953   [ +  +  -  + ]:         314 :         if (!had_toggle_up && had_toggle_down) {
    1954                 :           0 :             g_error(
    1955                 :             :                 "Finalizing wrapper for an object that's scheduled to be "
    1956                 :             :                 "unrooted: %s.%s\n",
    1957                 :             :                 ns(), name());
    1958                 :             :         }
    1959                 :             : 
    1960         [ +  + ]:         314 :         if (!m_gobj_disposed)
    1961                 :         160 :             g_object_weak_unref(m_ptr, wrapped_gobj_dispose_notify, this);
    1962                 :             : 
    1963         [ +  + ]:         314 :         if (!m_gobj_finalized)
    1964                 :         297 :             unset_object_qdata();
    1965                 :             : 
    1966                 :         314 :         bool was_using_toggle_refs = m_uses_toggle_ref;
    1967                 :         314 :         release_native_object();
    1968                 :             : 
    1969         [ +  + ]:         314 :         if (was_using_toggle_refs) {
    1970                 :             :             // We need to cancel again, to be sure that no other thread added
    1971                 :             :             // another toggle reference before we were removing the last one.
    1972                 :         159 :             ToggleQueue::get_default()->cancel(this);
    1973                 :             :         }
    1974                 :             :     }
    1975                 :             : 
    1976         [ -  + ]:        1568 :     if (wrapper_is_rooted()) {
    1977                 :             :         /* This happens when the refcount on the object is still >1,
    1978                 :             :          * for example with global objects GDK never frees like GdkDisplay,
    1979                 :             :          * when we close down the JS runtime.
    1980                 :             :          */
    1981                 :           0 :         gjs_debug(GJS_DEBUG_GOBJECT,
    1982                 :             :                   "Wrapper was finalized despite being kept alive, has refcount >1");
    1983                 :             : 
    1984                 :           0 :         debug_lifecycle("Unrooting object");
    1985                 :             : 
    1986                 :           0 :         discard_wrapper();
    1987                 :             :     }
    1988                 :        1568 :     unlink();
    1989                 :             : 
    1990                 :        1568 :     GJS_DEC_COUNTER(object_instance);
    1991                 :        1568 : }
    1992                 :             : 
    1993                 :         667 : ObjectPrototype::~ObjectPrototype() {
    1994                 :         667 :     invalidate_closure_vector(&m_vfuncs, this, &vfunc_invalidated_notify);
    1995                 :             : 
    1996                 :         667 :     g_type_class_unref(g_type_class_peek(m_gtype));
    1997                 :             : 
    1998                 :         667 :     GJS_DEC_COUNTER(object_prototype);
    1999                 :         667 : }
    2000                 :             : 
    2001                 :        2544 : static JSObject* gjs_lookup_object_constructor_from_info(JSContext* context,
    2002                 :             :                                                          GIBaseInfo* info,
    2003                 :             :                                                          GType gtype) {
    2004                 :        2544 :     g_return_val_if_fail(
    2005                 :             :         !info || GI_IS_OBJECT_INFO(info) || GI_IS_INTERFACE_INFO(info), NULL);
    2006                 :             : 
    2007                 :        2544 :     JS::RootedObject in_object(context);
    2008                 :             :     const char *constructor_name;
    2009                 :             : 
    2010         [ +  + ]:        2544 :     if (info) {
    2011                 :        2371 :         in_object = gjs_lookup_namespace_object(context, info);
    2012                 :        2371 :         constructor_name = g_base_info_get_name(info);
    2013                 :             :     } else {
    2014                 :         173 :         in_object = gjs_lookup_private_namespace(context);
    2015                 :         173 :         constructor_name = g_type_name(gtype);
    2016                 :             :     }
    2017                 :             : 
    2018         [ -  + ]:        2544 :     if (G_UNLIKELY (!in_object))
    2019                 :           0 :         return NULL;
    2020                 :             : 
    2021                 :             :     bool found;
    2022         [ -  + ]:        2544 :     if (!JS_HasProperty(context, in_object, constructor_name, &found))
    2023                 :           0 :         return NULL;
    2024                 :             : 
    2025                 :        2544 :     JS::RootedValue value(context);
    2026   [ +  +  -  +  :        2544 :     if (found && !JS_GetProperty(context, in_object, constructor_name, &value))
                   -  + ]
    2027                 :           0 :         return NULL;
    2028                 :             : 
    2029                 :        2544 :     JS::RootedObject constructor(context);
    2030         [ +  + ]:        2544 :     if (value.isUndefined()) {
    2031                 :             :         /* In case we're looking for a private type, and we don't find it,
    2032                 :             :            we need to define it first.
    2033                 :             :         */
    2034                 :          58 :         JS::RootedObject ignored(context);
    2035         [ -  + ]:          58 :         if (!ObjectPrototype::define_class(context, in_object, nullptr, gtype,
    2036                 :             :                                            nullptr, 0, &constructor, &ignored))
    2037                 :           0 :             return nullptr;
    2038         [ +  - ]:          58 :     } else {
    2039         [ -  + ]:        2486 :         if (G_UNLIKELY (!value.isObject()))
    2040                 :           0 :             return NULL;
    2041                 :             : 
    2042                 :        2486 :         constructor = &value.toObject();
    2043                 :             :     }
    2044                 :             : 
    2045                 :        2544 :     g_assert(constructor);
    2046                 :             : 
    2047                 :        2544 :     return constructor;
    2048                 :        2544 : }
    2049                 :             : 
    2050                 :             : GJS_JSAPI_RETURN_CONVENTION
    2051                 :        2025 : static JSObject* gjs_lookup_object_prototype_from_info(JSContext* context,
    2052                 :             :                                                        GIBaseInfo* info,
    2053                 :             :                                                        GType gtype) {
    2054                 :        2025 :     g_return_val_if_fail(
    2055                 :             :         !info || GI_IS_OBJECT_INFO(info) || GI_IS_INTERFACE_INFO(info), NULL);
    2056                 :             : 
    2057                 :             :     JS::RootedObject constructor(context,
    2058                 :        2025 :         gjs_lookup_object_constructor_from_info(context, info, gtype));
    2059                 :             : 
    2060         [ -  + ]:        2025 :     if (G_UNLIKELY(!constructor))
    2061                 :           0 :         return NULL;
    2062                 :             : 
    2063                 :        2025 :     const GjsAtoms& atoms = GjsContextPrivate::atoms(context);
    2064                 :        2025 :     JS::RootedObject prototype(context);
    2065         [ -  + ]:        2025 :     if (!gjs_object_require_property(context, constructor, "constructor object",
    2066                 :             :                                      atoms.prototype(), &prototype))
    2067                 :           0 :         return NULL;
    2068                 :             : 
    2069                 :        2025 :     return prototype;
    2070                 :        2025 : }
    2071                 :             : 
    2072                 :             : GJS_JSAPI_RETURN_CONVENTION
    2073                 :             : static JSObject *
    2074                 :        1253 : gjs_lookup_object_prototype(JSContext *context,
    2075                 :             :                             GType      gtype)
    2076                 :             : {
    2077                 :        1253 :     GjsAutoObjectInfo info = gjs_lookup_gtype(nullptr, gtype);
    2078                 :        1253 :     return gjs_lookup_object_prototype_from_info(context, info, gtype);
    2079                 :        1253 : }
    2080                 :             : 
    2081                 :             : // Retrieves a GIFieldInfo for a field named @key. This is for use in
    2082                 :             : // field_getter_impl() and field_setter_not_impl(), where the field info *must*
    2083                 :             : // have been cached previously in resolve_impl() on this ObjectPrototype or one
    2084                 :             : // of its parent ObjectPrototypes. This will fail an assertion if there is no
    2085                 :             : // cached field info.
    2086                 :             : //
    2087                 :             : // The caller does not own the return value, and it can never be null.
    2088                 :          12 : GIFieldInfo* ObjectPrototype::lookup_cached_field_info(JSContext* cx,
    2089                 :             :                                                        JS::HandleString key) {
    2090         [ -  + ]:          12 :     if (!info()) {
    2091                 :             :         // Custom JS classes can't have fields, and fields on internal classes
    2092                 :             :         // are not available. We must be looking up a field on a
    2093                 :             :         // GObject-introspected parent.
    2094                 :           0 :         GType parent_gtype = g_type_parent(m_gtype);
    2095                 :           0 :         g_assert(parent_gtype != G_TYPE_INVALID &&
    2096                 :             :                  "Custom JS class must have parent");
    2097                 :             :         ObjectPrototype* parent_proto =
    2098                 :           0 :             ObjectPrototype::for_gtype(parent_gtype);
    2099                 :             : 
    2100         [ #  # ]:           0 :         if (!parent_proto) {
    2101                 :           0 :             JS::RootedObject proto(cx, gjs_lookup_object_prototype(cx, parent_gtype));
    2102                 :           0 :             parent_proto = ObjectPrototype::for_js(cx, proto);
    2103                 :           0 :         }
    2104                 :             : 
    2105                 :           0 :         g_assert(parent_proto &&
    2106                 :             :                  "Custom JS class's parent must have been accessed in JS");
    2107                 :           0 :         return parent_proto->lookup_cached_field_info(cx, key);
    2108                 :             :     }
    2109                 :             : 
    2110                 :             :     gjs_debug_jsprop(GJS_DEBUG_GOBJECT,
    2111                 :             :                      "Looking up cached field info for %s in '%s' prototype",
    2112                 :             :                      gjs_debug_string(key).c_str(), g_type_name(m_gtype));
    2113                 :          12 :     auto entry = m_field_cache.lookupForAdd(key);
    2114         [ +  + ]:          12 :     if (entry)
    2115                 :           9 :         return entry->value().get();
    2116                 :             : 
    2117                 :             :     // We must be looking up a field defined on a parent. Look up the prototype
    2118                 :             :     // object via its GIObjectInfo.
    2119                 :           3 :     GjsAutoObjectInfo parent_info = g_object_info_get_parent(m_info);
    2120                 :           3 :     JS::RootedObject parent_proto(cx, gjs_lookup_object_prototype_from_info(
    2121                 :           3 :                                           cx, parent_info, G_TYPE_INVALID));
    2122                 :           3 :     ObjectPrototype* parent = ObjectPrototype::for_js(cx, parent_proto);
    2123                 :           3 :     return parent->lookup_cached_field_info(cx, key);
    2124                 :           3 : }
    2125                 :             : 
    2126                 :         358 : bool ObjectInstance::associate_closure(JSContext* cx, GClosure* closure) {
    2127         [ +  - ]:         358 :     if (!is_prototype())
    2128                 :         358 :         to_instance()->ensure_uses_toggle_ref(cx);
    2129                 :             : 
    2130                 :         358 :     g_assert(std::find(m_closures.begin(), m_closures.end(), closure) ==
    2131                 :             :                  m_closures.end() &&
    2132                 :             :              "This closure was already associated with this object");
    2133                 :             : 
    2134                 :             :     /* This is a weak reference, and will be cleared when the closure is
    2135                 :             :      * invalidated */
    2136                 :         358 :     m_closures.push_back(closure);
    2137                 :         358 :     g_closure_add_invalidate_notifier(
    2138                 :             :         closure, this, &ObjectInstance::closure_invalidated_notify);
    2139                 :             : 
    2140                 :         358 :     return true;
    2141                 :             : }
    2142                 :             : 
    2143                 :         143 : void ObjectInstance::closure_invalidated_notify(void* data, GClosure* closure) {
    2144                 :             :     // This callback should *only* touch m_closures
    2145                 :         143 :     auto* priv = static_cast<ObjectInstance*>(data);
    2146                 :         143 :     Gjs::remove_one_from_unsorted_vector(&priv->m_closures, closure);
    2147                 :         143 : }
    2148                 :             : 
    2149                 :        2805 : void ObjectInstance::invalidate_closures() {
    2150                 :        2805 :     invalidate_closure_vector(&m_closures, this, &closure_invalidated_notify);
    2151                 :        2805 :     m_closures.shrink_to_fit();
    2152                 :        2805 : }
    2153                 :             : 
    2154                 :         318 : bool ObjectBase::connect(JSContext* cx, unsigned argc, JS::Value* vp) {
    2155   [ -  +  -  + ]:         318 :     GJS_CHECK_WRAPPER_PRIV(cx, argc, vp, args, obj, ObjectBase, priv);
    2156         [ -  + ]:         318 :     if (!priv->check_is_instance(cx, "connect to signals"))
    2157                 :           0 :         return false;
    2158                 :             : 
    2159                 :         318 :     return priv->to_instance()->connect_impl(cx, args, false);
    2160                 :         318 : }
    2161                 :             : 
    2162                 :           2 : bool ObjectBase::connect_after(JSContext* cx, unsigned argc, JS::Value* vp) {
    2163   [ -  +  -  + ]:           2 :     GJS_CHECK_WRAPPER_PRIV(cx, argc, vp, args, obj, ObjectBase, priv);
    2164         [ -  + ]:           2 :     if (!priv->check_is_instance(cx, "connect to signals"))
    2165                 :           0 :         return false;
    2166                 :             : 
    2167                 :           2 :     return priv->to_instance()->connect_impl(cx, args, true);
    2168                 :           2 : }
    2169                 :             : 
    2170                 :           1 : bool ObjectBase::connect_object(JSContext* cx, unsigned argc, JS::Value* vp) {
    2171   [ -  +  -  + ]:           1 :     GJS_CHECK_WRAPPER_PRIV(cx, argc, vp, args, obj, ObjectBase, priv);
    2172         [ -  + ]:           1 :     if (!priv->check_is_instance(cx, "connect to signals"))
    2173                 :           0 :         return false;
    2174                 :             : 
    2175                 :           1 :     return priv->to_instance()->connect_impl(cx, args, false, true);
    2176                 :           1 : }
    2177                 :             : 
    2178                 :         321 : bool ObjectInstance::connect_impl(JSContext* context, const JS::CallArgs& args,
    2179                 :             :                                   bool after, bool object) {
    2180                 :             :     gulong id;
    2181                 :             :     guint signal_id;
    2182                 :             :     GQuark signal_detail;
    2183         [ +  + ]:         641 :     const char* func_name = object  ? "connect_object"
    2184         [ +  + ]:         320 :                             : after ? "connect_after"
    2185                 :             :                                     : "connect";
    2186                 :             : 
    2187                 :             :     gjs_debug_gsignal("connect obj %p priv %p", m_wrapper.get(), this);
    2188                 :             : 
    2189         [ +  + ]:         321 :     if (!check_gobject_disposed_or_finalized("connect to any signal on")) {
    2190                 :           4 :         args.rval().setInt32(0);
    2191                 :           4 :         return true;
    2192                 :             :     }
    2193                 :             : 
    2194                 :         317 :     JS::UniqueChars signal_name;
    2195                 :         317 :     JS::RootedObject callback(context);
    2196                 :         317 :     JS::RootedObject associate_obj(context);
    2197                 :             :     GConnectFlags flags;
    2198         [ +  + ]:         317 :     if (object) {
    2199         [ -  + ]:           1 :         if (!gjs_parse_call_args(context, func_name, args, "sooi",
    2200                 :             :                                  "signal name", &signal_name, "callback",
    2201                 :             :                                  &callback, "gobject", &associate_obj,
    2202                 :             :                                  "connect_flags", &flags))
    2203                 :           0 :             return false;
    2204                 :             : 
    2205         [ -  + ]:           1 :         if (flags & G_CONNECT_SWAPPED) {
    2206                 :           0 :             gjs_throw(context, "Unsupported connect flag G_CONNECT_SWAPPED");
    2207                 :           0 :             return false;
    2208                 :             :         }
    2209                 :             : 
    2210                 :           1 :         after = flags & G_CONNECT_AFTER;
    2211                 :             :     } else {
    2212         [ -  + ]:         316 :         if (!gjs_parse_call_args(context, func_name, args, "so", "signal name",
    2213                 :             :                                  &signal_name, "callback", &callback))
    2214                 :           0 :             return false;
    2215                 :             :     }
    2216                 :             : 
    2217                 :             :     std::string dynamicString =
    2218                 :         317 :         format_name() + '.' + func_name + "('" + signal_name.get() + "')";
    2219                 :         317 :     AutoProfilerLabel label(context, "", dynamicString.c_str());
    2220                 :             : 
    2221         [ -  + ]:         317 :     if (!JS::IsCallable(callback)) {
    2222                 :           0 :         gjs_throw(context, "second arg must be a callback");
    2223                 :           0 :         return false;
    2224                 :             :     }
    2225                 :             : 
    2226         [ +  + ]:         317 :     if (!g_signal_parse_name(signal_name.get(), gtype(), &signal_id,
    2227                 :             :                              &signal_detail, true)) {
    2228                 :           1 :         gjs_throw(context, "No signal '%s' on object '%s'",
    2229                 :             :                   signal_name.get(), type_name());
    2230                 :           1 :         return false;
    2231                 :             :     }
    2232                 :             : 
    2233                 :         316 :     GClosure* closure = Gjs::Closure::create_for_signal(
    2234                 :             :         context, callback, "signal callback", signal_id);
    2235         [ -  + ]:         316 :     if (closure == NULL)
    2236                 :           0 :         return false;
    2237                 :             : 
    2238         [ +  + ]:         316 :     if (associate_obj.get() != nullptr) {
    2239                 :           1 :         ObjectInstance* obj = ObjectInstance::for_js(context, associate_obj);
    2240         [ -  + ]:           1 :         if (!obj)
    2241                 :           0 :             return false;
    2242                 :             : 
    2243         [ -  + ]:           1 :         if (!obj->associate_closure(context, closure))
    2244                 :           0 :             return false;
    2245         [ -  + ]:         315 :     } else if (!associate_closure(context, closure)) {
    2246                 :           0 :         return false;
    2247                 :             :     }
    2248                 :             : 
    2249                 :         316 :     id = g_signal_connect_closure_by_id(m_ptr, signal_id, signal_detail,
    2250                 :             :                                         closure, after);
    2251                 :             : 
    2252                 :         316 :     args.rval().setDouble(id);
    2253                 :             : 
    2254                 :         316 :     return true;
    2255                 :         317 : }
    2256                 :             : 
    2257                 :         172 : bool ObjectBase::emit(JSContext* cx, unsigned argc, JS::Value* vp) {
    2258   [ -  +  -  + ]:         172 :     GJS_CHECK_WRAPPER_PRIV(cx, argc, vp, args, obj, ObjectBase, priv);
    2259         [ -  + ]:         172 :     if (!priv->check_is_instance(cx, "emit signal"))
    2260                 :           0 :         return false;
    2261                 :             : 
    2262                 :         172 :     return priv->to_instance()->emit_impl(cx, args);
    2263                 :         171 : }
    2264                 :             : 
    2265                 :             : bool
    2266                 :         172 : ObjectInstance::emit_impl(JSContext          *context,
    2267                 :             :                           const JS::CallArgs& argv)
    2268                 :             : {
    2269                 :             :     guint signal_id;
    2270                 :             :     GQuark signal_detail;
    2271                 :             :     GSignalQuery signal_query;
    2272                 :             :     unsigned int i;
    2273                 :             : 
    2274                 :             :     gjs_debug_gsignal("emit obj %p priv %p argc %d", m_wrapper.get(), this,
    2275                 :             :                       argv.length());
    2276                 :             : 
    2277         [ +  + ]:         172 :     if (!check_gobject_finalized("emit any signal on")) {
    2278                 :           1 :         argv.rval().setUndefined();
    2279                 :           1 :         return true;
    2280                 :             :     }
    2281                 :             : 
    2282                 :         171 :     JS::UniqueChars signal_name;
    2283         [ -  + ]:         171 :     if (!gjs_parse_call_args(context, "emit", argv, "!s",
    2284                 :             :                              "signal name", &signal_name))
    2285                 :           0 :         return false;
    2286                 :             : 
    2287                 :             :     std::string dynamicString =
    2288                 :         171 :         format_name() + "emit('" + signal_name.get() + "')";
    2289                 :         171 :     AutoProfilerLabel label(context, "", dynamicString.c_str());
    2290                 :             : 
    2291         [ +  + ]:         171 :     if (!g_signal_parse_name(signal_name.get(), gtype(), &signal_id,
    2292                 :             :                              &signal_detail, false)) {
    2293                 :           1 :         gjs_throw(context, "No signal '%s' on object '%s'",
    2294                 :             :                   signal_name.get(), type_name());
    2295                 :           1 :         return false;
    2296                 :             :     }
    2297                 :             : 
    2298                 :         170 :     g_signal_query(signal_id, &signal_query);
    2299                 :             : 
    2300         [ -  + ]:         170 :     if ((argv.length() - 1) != signal_query.n_params) {
    2301                 :           0 :         gjs_throw(context, "Signal '%s' on %s requires %d args got %d",
    2302                 :             :                   signal_name.get(), type_name(), signal_query.n_params,
    2303                 :           0 :                   argv.length() - 1);
    2304                 :           0 :         return false;
    2305                 :             :     }
    2306                 :             : 
    2307                 :         170 :     AutoGValueVector instance_and_args;
    2308                 :         170 :     instance_and_args.reserve(signal_query.n_params + 1);
    2309                 :         170 :     std::vector<Gjs::AutoGValue*> args_to_steal;
    2310                 :         170 :     Gjs::AutoGValue& instance = instance_and_args.emplace_back(gtype());
    2311                 :         170 :     g_value_set_instance(&instance, m_ptr);
    2312                 :             : 
    2313         [ +  + ]:         233 :     for (i = 0; i < signal_query.n_params; ++i) {
    2314                 :          75 :         GType gtype = signal_query.param_types[i] & ~G_SIGNAL_TYPE_STATIC_SCOPE;
    2315                 :          75 :         Gjs::AutoGValue& value = instance_and_args.emplace_back(gtype);
    2316         [ +  + ]:          75 :         if ((signal_query.param_types[i] & G_SIGNAL_TYPE_STATIC_SCOPE) != 0) {
    2317         [ -  + ]:           3 :             if (!gjs_value_to_g_value_no_copy(context, argv[i + 1], &value))
    2318                 :          12 :                 return false;
    2319                 :             :         } else {
    2320         [ +  + ]:          72 :             if (!gjs_value_to_g_value(context, argv[i + 1], &value))
    2321                 :          12 :                 return false;
    2322                 :             :         }
    2323                 :             : 
    2324         [ +  + ]:          63 :         if (!ObjectBase::info())
    2325                 :          55 :             continue;
    2326                 :             : 
    2327                 :             :         GjsAutoSignalInfo signal_info = g_object_info_find_signal(
    2328                 :           8 :             ObjectBase::info(), signal_query.signal_name);
    2329         [ -  + ]:           8 :         if (!signal_info)
    2330                 :           0 :             continue;
    2331                 :             : 
    2332                 :           8 :         GjsAutoArgInfo arg_info = g_callable_info_get_arg(signal_info, i);
    2333         [ +  + ]:           8 :         if (g_arg_info_get_ownership_transfer(arg_info) !=
    2334                 :             :             GI_TRANSFER_NOTHING) {
    2335                 :             :             // FIXME(3v1n0): As it happens in many places in gjs, we can't track
    2336                 :             :             // (yet) containers content, so in case of transfer container we
    2337                 :             :             // can only leak.
    2338                 :           3 :             args_to_steal.push_back(&value);
    2339                 :             :         }
    2340         [ +  - ]:           8 :     }
    2341                 :             : 
    2342         [ +  + ]:         158 :     if (signal_query.return_type == G_TYPE_NONE) {
    2343                 :         131 :         g_signal_emitv(instance_and_args.data(), signal_id, signal_detail,
    2344                 :             :                        nullptr);
    2345                 :         130 :         argv.rval().setUndefined();
    2346                 :         130 :         std::for_each(args_to_steal.begin(), args_to_steal.end(),
    2347                 :           3 :                       [](Gjs::AutoGValue* value) { value->steal(); });
    2348                 :         130 :         return true;
    2349                 :             :     }
    2350                 :             : 
    2351                 :          27 :     GType gtype = signal_query.return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE;
    2352                 :          27 :     Gjs::AutoGValue rvalue(gtype);
    2353                 :          27 :     g_signal_emitv(instance_and_args.data(), signal_id, signal_detail, &rvalue);
    2354                 :             : 
    2355                 :          27 :     std::for_each(args_to_steal.begin(), args_to_steal.end(),
    2356                 :           0 :                   [](Gjs::AutoGValue* value) { value->steal(); });
    2357                 :             : 
    2358                 :          27 :     return gjs_value_from_g_value(context, argv.rval(), &rvalue);
    2359                 :         170 : }
    2360                 :             : 
    2361                 :          27 : bool ObjectInstance::signal_match_arguments_from_object(
    2362                 :             :     JSContext* cx, JS::HandleObject match_obj, GSignalMatchType* mask_out,
    2363                 :             :     unsigned* signal_id_out, GQuark* detail_out,
    2364                 :             :     JS::MutableHandleObject callable_out) {
    2365                 :          27 :     g_assert(mask_out && signal_id_out && detail_out && "forgot out parameter");
    2366                 :             : 
    2367                 :          27 :     int mask = 0;
    2368                 :          27 :     const GjsAtoms& atoms = GjsContextPrivate::atoms(cx);
    2369                 :             : 
    2370                 :             :     bool has_id;
    2371                 :          27 :     unsigned signal_id = 0;
    2372         [ -  + ]:          27 :     if (!JS_HasOwnPropertyById(cx, match_obj, atoms.signal_id(), &has_id))
    2373                 :           0 :         return false;
    2374         [ +  + ]:          27 :     if (has_id) {
    2375                 :           7 :         mask |= G_SIGNAL_MATCH_ID;
    2376                 :             : 
    2377                 :           7 :         JS::RootedValue value(cx);
    2378         [ -  + ]:           7 :         if (!JS_GetPropertyById(cx, match_obj, atoms.signal_id(), &value))
    2379                 :           0 :             return false;
    2380                 :             : 
    2381                 :           7 :         JS::UniqueChars signal_name = gjs_string_to_utf8(cx, value);
    2382         [ -  + ]:           7 :         if (!signal_name)
    2383                 :           0 :             return false;
    2384                 :             : 
    2385                 :           7 :         signal_id = g_signal_lookup(signal_name.get(), gtype());
    2386   [ +  -  +  - ]:           7 :     }
    2387                 :             : 
    2388                 :             :     bool has_detail;
    2389                 :          27 :     GQuark detail = 0;
    2390         [ -  + ]:          27 :     if (!JS_HasOwnPropertyById(cx, match_obj, atoms.detail(), &has_detail))
    2391                 :           0 :         return false;
    2392         [ +  + ]:          27 :     if (has_detail) {
    2393                 :           3 :         mask |= G_SIGNAL_MATCH_DETAIL;
    2394                 :             : 
    2395                 :           3 :         JS::RootedValue value(cx);
    2396         [ -  + ]:           3 :         if (!JS_GetPropertyById(cx, match_obj, atoms.detail(), &value))
    2397                 :           0 :             return false;
    2398                 :             : 
    2399                 :           3 :         JS::UniqueChars detail_string = gjs_string_to_utf8(cx, value);
    2400         [ -  + ]:           3 :         if (!detail_string)
    2401                 :           0 :             return false;
    2402                 :             : 
    2403                 :           3 :         detail = g_quark_from_string(detail_string.get());
    2404   [ +  -  +  - ]:           3 :     }
    2405                 :             : 
    2406                 :             :     bool has_func;
    2407                 :          27 :     JS::RootedObject callable(cx);
    2408         [ -  + ]:          27 :     if (!JS_HasOwnPropertyById(cx, match_obj, atoms.func(), &has_func))
    2409                 :           0 :         return false;
    2410         [ +  + ]:          27 :     if (has_func) {
    2411                 :          22 :         mask |= G_SIGNAL_MATCH_CLOSURE;
    2412                 :             : 
    2413                 :          22 :         JS::RootedValue value(cx);
    2414         [ -  + ]:          22 :         if (!JS_GetPropertyById(cx, match_obj, atoms.func(), &value))
    2415                 :           0 :             return false;
    2416                 :             : 
    2417   [ +  -  -  +  :          22 :         if (!value.isObject() || !JS::IsCallable(&value.toObject())) {
                   -  + ]
    2418                 :           0 :             gjs_throw(cx, "'func' property must be a function");
    2419                 :           0 :             return false;
    2420                 :             :         }
    2421                 :             : 
    2422                 :          22 :         callable = &value.toObject();
    2423         [ +  - ]:          22 :     }
    2424                 :             : 
    2425   [ +  +  +  +  :          27 :     if (!has_id && !has_detail && !has_func) {
                   -  + ]
    2426                 :           0 :         gjs_throw(cx, "Must specify at least one of signalId, detail, or func");
    2427                 :           0 :         return false;
    2428                 :             :     }
    2429                 :             : 
    2430                 :          27 :     *mask_out = GSignalMatchType(mask);
    2431         [ +  + ]:          27 :     if (has_id)
    2432                 :           7 :         *signal_id_out = signal_id;
    2433         [ +  + ]:          27 :     if (has_detail)
    2434                 :           3 :         *detail_out = detail;
    2435         [ +  + ]:          27 :     if (has_func)
    2436                 :          22 :         callable_out.set(callable);
    2437                 :          27 :     return true;
    2438                 :          27 : }
    2439                 :             : 
    2440                 :          12 : bool ObjectBase::signal_find(JSContext* cx, unsigned argc, JS::Value* vp) {
    2441   [ -  +  -  + ]:          12 :     GJS_CHECK_WRAPPER_PRIV(cx, argc, vp, args, obj, ObjectBase, priv);
    2442         [ -  + ]:          12 :     if (!priv->check_is_instance(cx, "find signal"))
    2443                 :           0 :         return false;
    2444                 :             : 
    2445                 :          12 :     return priv->to_instance()->signal_find_impl(cx, args);
    2446                 :          12 : }
    2447                 :             : 
    2448                 :          12 : bool ObjectInstance::signal_find_impl(JSContext* cx, const JS::CallArgs& args) {
    2449                 :             :     gjs_debug_gsignal("[Gi.signal_find_symbol]() obj %p priv %p argc %d",
    2450                 :             :                       m_wrapper.get(), this, args.length());
    2451                 :             : 
    2452         [ -  + ]:          12 :     if (!check_gobject_finalized("find any signal on")) {
    2453                 :           0 :         args.rval().setInt32(0);
    2454                 :           0 :         return true;
    2455                 :             :     }
    2456                 :             : 
    2457                 :          12 :     JS::RootedObject match(cx);
    2458         [ -  + ]:          12 :     if (!gjs_parse_call_args(cx, "[Gi.signal_find_symbol]", args, "o", "match",
    2459                 :             :                              &match))
    2460                 :           0 :         return false;
    2461                 :             : 
    2462                 :             :     GSignalMatchType mask;
    2463                 :             :     unsigned signal_id;
    2464                 :             :     GQuark detail;
    2465                 :          12 :     JS::RootedObject callable(cx);
    2466         [ -  + ]:          12 :     if (!signal_match_arguments_from_object(cx, match, &mask, &signal_id,
    2467                 :             :                                             &detail, &callable))
    2468                 :           0 :         return false;
    2469                 :             : 
    2470                 :          12 :     uint64_t handler = 0;
    2471         [ +  + ]:          12 :     if (!callable) {
    2472                 :           5 :         handler = g_signal_handler_find(m_ptr, mask, signal_id, detail, nullptr,
    2473                 :             :                                         nullptr, nullptr);
    2474                 :             :     } else {
    2475         [ +  - ]:          23 :         for (GClosure* candidate : m_closures) {
    2476         [ +  + ]:          23 :             if (Gjs::Closure::for_gclosure(candidate)->callable() == callable) {
    2477                 :           7 :                 handler = g_signal_handler_find(m_ptr, mask, signal_id, detail,
    2478                 :             :                                                 candidate, nullptr, nullptr);
    2479         [ +  - ]:           7 :                 if (handler != 0)
    2480                 :           7 :                     break;
    2481                 :             :             }
    2482                 :             :         }
    2483                 :             :     }
    2484                 :             : 
    2485                 :          12 :     args.rval().setNumber(static_cast<double>(handler));
    2486                 :          12 :     return true;
    2487                 :          12 : }
    2488                 :             : 
    2489                 :             : template <ObjectBase::SignalMatchFunc(*MatchFunc)>
    2490                 :             : static inline const char* signal_match_to_action_name();
    2491                 :             : 
    2492                 :             : template <>
    2493                 :             : inline const char*
    2494                 :          12 : signal_match_to_action_name<&g_signal_handlers_block_matched>() {
    2495                 :          12 :     return "block";
    2496                 :             : }
    2497                 :             : 
    2498                 :             : template <>
    2499                 :             : inline const char*
    2500                 :          12 : signal_match_to_action_name<&g_signal_handlers_unblock_matched>() {
    2501                 :          12 :     return "unblock";
    2502                 :             : }
    2503                 :             : 
    2504                 :             : template <>
    2505                 :             : inline const char*
    2506                 :          12 : signal_match_to_action_name<&g_signal_handlers_disconnect_matched>() {
    2507                 :          12 :     return "disconnect";
    2508                 :             : }
    2509                 :             : 
    2510                 :             : template <ObjectBase::SignalMatchFunc(*MatchFunc)>
    2511                 :          18 : bool ObjectBase::signals_action(JSContext* cx, unsigned argc, JS::Value* vp) {
    2512   [ -  +  -  + ]:          18 :     GJS_CHECK_WRAPPER_PRIV(cx, argc, vp, args, obj, ObjectBase, priv);
    2513                 :          18 :     const std::string action_name = signal_match_to_action_name<MatchFunc>();
    2514         [ -  + ]:          18 :     if (!priv->check_is_instance(cx, (action_name + " signal").c_str()))
    2515                 :           0 :         return false;
    2516                 :             : 
    2517                 :          18 :     return priv->to_instance()->signals_action_impl<MatchFunc>(cx, args);
    2518                 :          18 : }
    2519                 :             : 
    2520                 :             : template <ObjectBase::SignalMatchFunc(*MatchFunc)>
    2521                 :          18 : bool ObjectInstance::signals_action_impl(JSContext* cx,
    2522                 :             :                                          const JS::CallArgs& args) {
    2523                 :          18 :     const std::string action_name = signal_match_to_action_name<MatchFunc>();
    2524                 :          18 :     const std::string action_tag = "[Gi.signals_" + action_name + "_symbol]";
    2525                 :             :     gjs_debug_gsignal("[%s]() obj %p priv %p argc %d", action_tag.c_str(),
    2526                 :             :                       m_wrapper.get(), this, args.length());
    2527                 :             : 
    2528         [ +  + ]:          18 :     if (!check_gobject_finalized((action_name + " any signal on").c_str())) {
    2529                 :           3 :         args.rval().setInt32(0);
    2530                 :           3 :         return true;
    2531                 :             :     }
    2532                 :          15 :     JS::RootedObject match(cx);
    2533         [ -  + ]:          15 :     if (!gjs_parse_call_args(cx, action_tag.c_str(), args, "o", "match",
    2534                 :             :                              &match)) {
    2535                 :           0 :         return false;
    2536                 :             :     }
    2537                 :             :     GSignalMatchType mask;
    2538                 :             :     unsigned signal_id;
    2539                 :             :     GQuark detail;
    2540                 :          15 :     JS::RootedObject callable(cx);
    2541         [ -  + ]:          15 :     if (!signal_match_arguments_from_object(cx, match, &mask, &signal_id,
    2542                 :             :                                             &detail, &callable)) {
    2543                 :           0 :         return false;
    2544                 :             :     }
    2545                 :          15 :     unsigned n_matched = 0;
    2546         [ -  + ]:          15 :     if (!callable) {
    2547                 :           0 :         n_matched = MatchFunc(m_ptr, mask, signal_id, detail, nullptr, nullptr,
    2548                 :             :                               nullptr);
    2549                 :             :     } else {
    2550                 :          15 :         std::vector<GClosure*> candidates;
    2551         [ +  + ]:          99 :         for (GClosure* candidate : m_closures) {
    2552         [ +  + ]:          84 :             if (Gjs::Closure::for_gclosure(candidate)->callable() == callable)
    2553                 :          15 :                 candidates.push_back(candidate);
    2554                 :             :         }
    2555         [ +  + ]:          30 :         for (GClosure* candidate : candidates) {
    2556                 :          15 :             n_matched += MatchFunc(m_ptr, mask, signal_id, detail, candidate,
    2557                 :             :                                    nullptr, nullptr);
    2558                 :             :         }
    2559                 :          15 :     }
    2560                 :             : 
    2561                 :          15 :     args.rval().setNumber(n_matched);
    2562                 :          15 :     return true;
    2563                 :          18 : }
    2564                 :             : 
    2565                 :         216 : bool ObjectBase::to_string(JSContext* cx, unsigned argc, JS::Value* vp) {
    2566   [ -  +  -  + ]:         216 :     GJS_CHECK_WRAPPER_PRIV(cx, argc, vp, args, obj, ObjectBase, priv);
    2567                 :         216 :     const char* kind = ObjectBase::DEBUG_TAG;
    2568         [ +  + ]:         216 :     if (!priv->is_prototype())
    2569                 :         214 :         kind = priv->to_instance()->to_string_kind();
    2570         [ +  + ]:         646 :     return gjs_wrapper_to_string_func(
    2571                 :             :         cx, obj, kind, priv->info(), priv->gtype(),
    2572                 :         430 :         priv->is_prototype() ? nullptr : priv->to_instance()->ptr(),
    2573                 :         216 :         args.rval());
    2574                 :         216 : }
    2575                 :             : 
    2576                 :             : /*
    2577                 :             :  * ObjectInstance::to_string_kind:
    2578                 :             :  *
    2579                 :             :  * ObjectInstance shows a "disposed" marker in its toString() method if the
    2580                 :             :  * wrapped GObject has already been disposed.
    2581                 :             :  */
    2582                 :         214 : const char* ObjectInstance::to_string_kind(void) const {
    2583         [ +  + ]:         214 :     if (m_gobj_finalized)
    2584                 :           3 :         return "object (FINALIZED)";
    2585         [ +  + ]:         211 :     return m_gobj_disposed ? "object (DISPOSED)" : "object";
    2586                 :             : }
    2587                 :             : 
    2588                 :             : /*
    2589                 :             :  * ObjectBase::init_gobject:
    2590                 :             :  *
    2591                 :             :  * This is named "init_gobject()" but corresponds to "_init()" in JS. The reason
    2592                 :             :  * for the name is that an "init()" method is used within SpiderMonkey to
    2593                 :             :  * indicate fallible initialization that must be done before an object can be
    2594                 :             :  * used, which is not the case here.
    2595                 :             :  */
    2596                 :         906 : bool ObjectBase::init_gobject(JSContext* context, unsigned argc,
    2597                 :             :                               JS::Value* vp) {
    2598   [ -  +  -  + ]:         906 :     GJS_CHECK_WRAPPER_PRIV(context, argc, vp, argv, obj, ObjectBase, priv);
    2599         [ -  + ]:         906 :     if (!priv->check_is_instance(context, "initialize"))
    2600                 :           0 :         return false;
    2601                 :             : 
    2602                 :         906 :     std::string dynamicString = priv->format_name() + "._init";
    2603                 :         906 :     AutoProfilerLabel label(context, "", dynamicString.c_str());
    2604                 :             : 
    2605                 :         906 :     return priv->to_instance()->init_impl(context, argv, obj);
    2606                 :         906 : }
    2607                 :             : 
    2608                 :             : // clang-format off
    2609                 :             : const struct JSClassOps ObjectBase::class_ops = {
    2610                 :             :     &ObjectBase::add_property,
    2611                 :             :     nullptr,  // deleteProperty
    2612                 :             :     nullptr,  // enumerate
    2613                 :             :     &ObjectBase::new_enumerate,
    2614                 :             :     &ObjectBase::resolve,
    2615                 :             :     nullptr,  // mayResolve
    2616                 :             :     &ObjectBase::finalize,
    2617                 :             :     NULL,
    2618                 :             :     NULL,
    2619                 :             :     &ObjectBase::trace,
    2620                 :             : };
    2621                 :             : 
    2622                 :             : const struct JSClass ObjectBase::klass = {
    2623                 :             :     "GObject_Object",
    2624                 :             :     JSCLASS_HAS_RESERVED_SLOTS(1) | JSCLASS_FOREGROUND_FINALIZE,
    2625                 :             :     &ObjectBase::class_ops
    2626                 :             : };
    2627                 :             : 
    2628                 :             : JSFunctionSpec ObjectBase::proto_methods[] = {
    2629                 :             :     JS_FN("_init", &ObjectBase::init_gobject, 0, 0),
    2630                 :             :     JS_FN("connect", &ObjectBase::connect, 0, 0),
    2631                 :             :     JS_FN("connect_after", &ObjectBase::connect_after, 0, 0),
    2632                 :             :     JS_FN("connect_object", &ObjectBase::connect_object, 0, 0),
    2633                 :             :     JS_FN("emit", &ObjectBase::emit, 0, 0),
    2634                 :             :     JS_FS_END
    2635                 :             : };
    2636                 :             : 
    2637                 :             : JSPropertySpec ObjectBase::proto_properties[] = {
    2638                 :             :     JS_STRING_SYM_PS(toStringTag, "GObject_Object", JSPROP_READONLY),
    2639                 :             :     JS_PS_END};
    2640                 :             : // clang-format on
    2641                 :             : 
    2642                 :             : // Override of GIWrapperPrototype::get_parent_proto()
    2643                 :         670 : bool ObjectPrototype::get_parent_proto(JSContext* cx,
    2644                 :             :                                        JS::MutableHandleObject proto) const {
    2645                 :         670 :     GType parent_type = g_type_parent(gtype());
    2646         [ +  + ]:         670 :     if (parent_type == G_TYPE_INVALID) {
    2647                 :          76 :         proto.set(nullptr);
    2648                 :          76 :         return true;
    2649                 :             :     }
    2650                 :             : 
    2651                 :         594 :     JSObject* prototype = gjs_lookup_object_prototype(cx, parent_type);
    2652         [ -  + ]:         594 :     if (!prototype)
    2653                 :           0 :         return false;
    2654                 :             : 
    2655                 :         594 :     proto.set(prototype);
    2656                 :         594 :     return true;
    2657                 :             : }
    2658                 :             : 
    2659                 :         580 : bool ObjectPrototype::get_parent_constructor(
    2660                 :             :     JSContext* cx, JS::MutableHandleObject constructor) const {
    2661                 :         580 :     GType parent_type = g_type_parent(gtype());
    2662                 :             : 
    2663         [ +  + ]:         580 :     if (parent_type == G_TYPE_INVALID) {
    2664                 :          76 :         constructor.set(nullptr);
    2665                 :          76 :         return true;
    2666                 :             :     }
    2667                 :             : 
    2668                 :         504 :     JS::RootedValue v_constructor(cx);
    2669         [ -  + ]:         504 :     if (!gjs_lookup_object_constructor(cx, parent_type, &v_constructor))
    2670                 :           0 :         return false;
    2671                 :             : 
    2672                 :         504 :     g_assert(v_constructor.isObject() &&
    2673                 :             :              "gjs_lookup_object_constructor() should always produce an object");
    2674                 :         504 :     constructor.set(&v_constructor.toObject());
    2675                 :         504 :     return true;
    2676                 :         504 : }
    2677                 :             : 
    2678                 :         670 : void ObjectPrototype::set_interfaces(GType* interface_gtypes,
    2679                 :             :                                      uint32_t n_interface_gtypes) {
    2680         [ +  + ]:         670 :     if (interface_gtypes) {
    2681         [ +  + ]:          73 :         for (uint32_t n = 0; n < n_interface_gtypes; n++) {
    2682                 :          39 :             m_interface_gtypes.push_back(interface_gtypes[n]);
    2683                 :             :         }
    2684                 :             :     }
    2685                 :         670 : }
    2686                 :             : 
    2687                 :             : /*
    2688                 :             :  * ObjectPrototype::define_class:
    2689                 :             :  * @in_object: Object where the constructor is stored, typically a repo object.
    2690                 :             :  * @info: Introspection info for the GObject class.
    2691                 :             :  * @gtype: #GType for the GObject class.
    2692                 :             :  * @constructor: Return location for the constructor object.
    2693                 :             :  * @prototype: Return location for the prototype object.
    2694                 :             :  *
    2695                 :             :  * Define a GObject class constructor and prototype, including all the
    2696                 :             :  * necessary methods and properties that are not introspected. Provides the
    2697                 :             :  * constructor and prototype objects as out parameters, for convenience
    2698                 :             :  * elsewhere.
    2699                 :             :  */
    2700                 :         580 : bool ObjectPrototype::define_class(
    2701                 :             :     JSContext* context, JS::HandleObject in_object, GIObjectInfo* info,
    2702                 :             :     GType gtype, GType* interface_gtypes, uint32_t n_interface_gtypes,
    2703                 :             :     JS::MutableHandleObject constructor, JS::MutableHandleObject prototype) {
    2704                 :         580 :     ObjectPrototype* priv = ObjectPrototype::create_class(
    2705                 :             :         context, in_object, info, gtype, constructor, prototype);
    2706         [ -  + ]:         580 :     if (!priv)
    2707                 :           0 :         return false;
    2708                 :             : 
    2709                 :         580 :     priv->set_interfaces(interface_gtypes, n_interface_gtypes);
    2710                 :             : 
    2711                 :         580 :     JS::RootedObject parent_constructor(context);
    2712         [ -  + ]:         580 :     if (!priv->get_parent_constructor(context, &parent_constructor))
    2713                 :           0 :         return false;
    2714                 :             :     // If this is a fundamental constructor (e.g. GObject.Object) the
    2715                 :             :     // parent constructor may be null.
    2716         [ +  + ]:         580 :     if (parent_constructor) {
    2717         [ -  + ]:         504 :         if (!JS_SetPrototype(context, constructor, parent_constructor))
    2718                 :           0 :             return false;
    2719                 :             :     }
    2720                 :             : 
    2721                 :             :     // hook_up_vfunc and the signal handler matcher functions can't be included
    2722                 :             :     // in gjs_object_instance_proto_funcs because they are custom symbols.
    2723                 :         580 :     const GjsAtoms& atoms = GjsContextPrivate::atoms(context);
    2724                 :         580 :     return JS_DefineFunctionById(context, prototype, atoms.hook_up_vfunc(),
    2725                 :             :                                  &ObjectBase::hook_up_vfunc, 3,
    2726         [ +  - ]:         580 :                                  GJS_MODULE_PROP_FLAGS) &&
    2727                 :         580 :            JS_DefineFunctionById(context, prototype, atoms.signal_find(),
    2728                 :             :                                  &ObjectBase::signal_find, 1,
    2729         [ +  - ]:         580 :                                  GJS_MODULE_PROP_FLAGS) &&
    2730                 :         580 :            JS_DefineFunctionById(
    2731                 :             :                context, prototype, atoms.signals_block(),
    2732                 :           5 :                &ObjectBase::signals_action<&g_signal_handlers_block_matched>, 1,
    2733         [ +  - ]:         580 :                GJS_MODULE_PROP_FLAGS) &&
    2734                 :         580 :            JS_DefineFunctionById(
    2735                 :             :                context, prototype, atoms.signals_unblock(),
    2736                 :           5 :                &ObjectBase::signals_action<&g_signal_handlers_unblock_matched>,
    2737   [ +  -  +  - ]:        1160 :                1, GJS_MODULE_PROP_FLAGS) &&
    2738                 :         580 :            JS_DefineFunctionById(context, prototype, atoms.signals_disconnect(),
    2739                 :             :                                  &ObjectBase::signals_action<
    2740                 :           5 :                                      &g_signal_handlers_disconnect_matched>,
    2741                 :         580 :                                  1, GJS_MODULE_PROP_FLAGS);
    2742                 :         580 : }
    2743                 :             : 
    2744                 :             : /*
    2745                 :             :  * ObjectInstance::init_custom_class_from_gobject:
    2746                 :             :  *
    2747                 :             :  * Does all the necessary initialization for an ObjectInstance and JSObject
    2748                 :             :  * wrapper, given a newly-created GObject pointer, of a GObject class that was
    2749                 :             :  * created in JS with GObject.registerClass(). This is called from the GObject's
    2750                 :             :  * instance init function in gobject.cpp, and that's the only reason it's a
    2751                 :             :  * public method.
    2752                 :             :  */
    2753                 :         481 : bool ObjectInstance::init_custom_class_from_gobject(JSContext* cx,
    2754                 :             :                                                     JS::HandleObject wrapper,
    2755                 :             :                                                     GObject* gobj) {
    2756                 :         481 :     associate_js_gobject(cx, wrapper, gobj);
    2757                 :             : 
    2758                 :             :     // Custom JS objects will most likely have visible state, so just do this
    2759                 :             :     // from the start.
    2760                 :         481 :     ensure_uses_toggle_ref(cx);
    2761         [ -  + ]:         481 :     if (!m_uses_toggle_ref) {
    2762                 :           0 :         gjs_throw(cx, "Impossible to set toggle references on %sobject %p",
    2763         [ #  # ]:           0 :                   m_gobj_disposed ? "disposed " : "", gobj);
    2764                 :           0 :         return false;
    2765                 :             :     }
    2766                 :             : 
    2767                 :         481 :     const GjsAtoms& atoms = GjsContextPrivate::atoms(cx);
    2768                 :         481 :     JS::RootedValue v(cx);
    2769         [ -  + ]:         481 :     if (!JS_GetPropertyById(cx, wrapper, atoms.instance_init(), &v))
    2770                 :           0 :         return false;
    2771                 :             : 
    2772         [ +  + ]:         481 :     if (v.isUndefined())
    2773                 :         434 :         return true;
    2774   [ +  -  -  +  :          47 :     if (!v.isObject() || !JS::IsCallable(&v.toObject())) {
                   -  + ]
    2775                 :           0 :         gjs_throw(cx, "_instance_init property was not a function");
    2776                 :           0 :         return false;
    2777                 :             :     }
    2778                 :             : 
    2779                 :          47 :     JS::RootedValue ignored_rval(cx);
    2780                 :          47 :     return JS_CallFunctionValue(cx, wrapper, v, JS::HandleValueArray::empty(),
    2781                 :          47 :                                 &ignored_rval);
    2782                 :         481 : }
    2783                 :             : 
    2784                 :             : /*
    2785                 :             :  * ObjectInstance::new_for_gobject:
    2786                 :             :  *
    2787                 :             :  * Creates a new JSObject wrapper for the GObject pointer @gobj, and an
    2788                 :             :  * ObjectInstance private structure to go along with it.
    2789                 :             :  */
    2790                 :         659 : ObjectInstance* ObjectInstance::new_for_gobject(JSContext* cx, GObject* gobj) {
    2791                 :         659 :     g_assert(gobj && "Cannot create JSObject for null GObject pointer");
    2792                 :             : 
    2793                 :         659 :     GType gtype = G_TYPE_FROM_INSTANCE(gobj);
    2794                 :             : 
    2795                 :             :     gjs_debug_marshal(GJS_DEBUG_GOBJECT, "Wrapping %s %p with JSObject",
    2796                 :             :                       g_type_name(gtype), gobj);
    2797                 :             : 
    2798                 :         659 :     JS::RootedObject proto(cx, gjs_lookup_object_prototype(cx, gtype));
    2799         [ -  + ]:         659 :     if (!proto)
    2800                 :           0 :         return nullptr;
    2801                 :             : 
    2802                 :             :     JS::RootedObject obj(
    2803                 :         659 :         cx, JS_NewObjectWithGivenProto(cx, &ObjectBase::klass, proto));
    2804         [ -  + ]:         659 :     if (!obj)
    2805                 :           0 :         return nullptr;
    2806                 :             : 
    2807                 :         659 :     ObjectPrototype* prototype = resolve_prototype(cx, proto);
    2808         [ -  + ]:         659 :     if (!prototype)
    2809                 :           0 :         return nullptr;
    2810                 :             : 
    2811                 :         659 :     ObjectInstance* priv = new ObjectInstance(prototype, obj);
    2812                 :             : 
    2813                 :         659 :     ObjectBase::init_private(obj, priv);
    2814                 :             : 
    2815                 :         659 :     g_object_ref_sink(gobj);
    2816                 :         659 :     priv->associate_js_gobject(cx, obj, gobj);
    2817                 :             : 
    2818                 :         659 :     g_assert(priv->wrapper() == obj.get());
    2819                 :             : 
    2820                 :         659 :     return priv;
    2821                 :         659 : }
    2822                 :             : 
    2823                 :             : /*
    2824                 :             :  * ObjectInstance::wrapper_from_gobject:
    2825                 :             :  *
    2826                 :             :  * Gets a JSObject wrapper for the GObject pointer @gobj. If one already exists,
    2827                 :             :  * then it is returned. Otherwise a new one is created with
    2828                 :             :  * ObjectInstance::new_for_gobject().
    2829                 :             :  */
    2830                 :        1851 : JSObject* ObjectInstance::wrapper_from_gobject(JSContext* cx, GObject* gobj) {
    2831                 :        1851 :     g_assert(gobj && "Cannot get JSObject for null GObject pointer");
    2832                 :             : 
    2833                 :        1851 :     ObjectInstance* priv = ObjectInstance::for_gobject(gobj);
    2834                 :             : 
    2835         [ +  + ]:        1851 :     if (!priv) {
    2836                 :             :         /* We have to create a wrapper */
    2837                 :         640 :         priv = new_for_gobject(cx, gobj);
    2838         [ -  + ]:         640 :         if (!priv)
    2839                 :           0 :             return nullptr;
    2840                 :             :     }
    2841                 :             : 
    2842                 :        1851 :     return priv->wrapper();
    2843                 :             : }
    2844                 :             : 
    2845                 :        1745 : bool ObjectInstance::set_value_from_gobject(JSContext* cx, GObject* gobj,
    2846                 :             :                                             JS::MutableHandleValue value_p) {
    2847         [ -  + ]:        1745 :     if (!gobj) {
    2848                 :           0 :         value_p.setNull();
    2849                 :           0 :         return true;
    2850                 :             :     }
    2851                 :             : 
    2852                 :        1745 :     auto* wrapper = ObjectInstance::wrapper_from_gobject(cx, gobj);
    2853         [ +  - ]:        1745 :     if (wrapper) {
    2854                 :        1745 :         value_p.setObject(*wrapper);
    2855                 :        1745 :         return true;
    2856                 :             :     }
    2857                 :             : 
    2858                 :           0 :     gjs_throw(cx, "Failed to find JS object for GObject %p of type %s", gobj,
    2859                 :           0 :               g_type_name(G_TYPE_FROM_INSTANCE(gobj)));
    2860                 :           0 :     return false;
    2861                 :             : }
    2862                 :             : 
    2863                 :             : // Replaces GIWrapperBase::to_c_ptr(). The GIWrapperBase version is deleted.
    2864                 :        1994 : bool ObjectBase::to_c_ptr(JSContext* cx, JS::HandleObject obj, GObject** ptr) {
    2865                 :        1994 :     g_assert(ptr);
    2866                 :             : 
    2867                 :        1994 :     auto* priv = ObjectBase::for_js(cx, obj);
    2868   [ +  +  -  +  :        1994 :     if (!priv || priv->is_prototype())
                   +  + ]
    2869                 :           1 :         return false;
    2870                 :             : 
    2871                 :        1993 :     ObjectInstance* instance = priv->to_instance();
    2872         [ +  + ]:        1993 :     if (!instance->check_gobject_finalized("access")) {
    2873                 :           2 :         *ptr = nullptr;
    2874                 :           2 :         return true;
    2875                 :             :     }
    2876                 :             : 
    2877                 :        1991 :     *ptr = instance->ptr();
    2878                 :        1991 :     return true;
    2879                 :             : }
    2880                 :             : 
    2881                 :             : // Overrides GIWrapperBase::transfer_to_gi_argument().
    2882                 :        1941 : bool ObjectBase::transfer_to_gi_argument(JSContext* cx, JS::HandleObject obj,
    2883                 :             :                                          GIArgument* arg,
    2884                 :             :                                          GIDirection transfer_direction,
    2885                 :             :                                          GITransfer transfer_ownership,
    2886                 :             :                                          GType expected_gtype,
    2887                 :             :                                          GIBaseInfo* expected_info) {
    2888                 :        1941 :     g_assert(transfer_direction != GI_DIRECTION_INOUT &&
    2889                 :             :              "transfer_to_gi_argument() must choose between in or out");
    2890                 :             : 
    2891         [ +  + ]:        1941 :     if (!ObjectBase::typecheck(cx, obj, expected_info, expected_gtype)) {
    2892                 :           5 :         gjs_arg_unset<void*>(arg);
    2893                 :           5 :         return false;
    2894                 :             :     }
    2895                 :             : 
    2896                 :             :     GObject* ptr;
    2897         [ -  + ]:        1936 :     if (!ObjectBase::to_c_ptr(cx, obj, &ptr))
    2898                 :           0 :         return false;
    2899                 :             : 
    2900                 :        1936 :     gjs_arg_set(arg, ptr);
    2901                 :             : 
    2902                 :             :     // Pointer can be null if object was already disposed by C code
    2903         [ +  + ]:        1936 :     if (!ptr)
    2904                 :           2 :         return true;
    2905                 :             : 
    2906   [ +  -  +  + ]:        1934 :     if ((transfer_direction == GI_DIRECTION_IN &&
    2907         [ -  + ]:        1876 :          transfer_ownership != GI_TRANSFER_NOTHING) ||
    2908         [ #  # ]:           0 :         (transfer_direction == GI_DIRECTION_OUT &&
    2909                 :             :          transfer_ownership == GI_TRANSFER_EVERYTHING)) {
    2910                 :          58 :         gjs_arg_set(arg, ObjectInstance::copy_ptr(cx, expected_gtype,
    2911                 :             :                                                   gjs_arg_get<void*>(arg)));
    2912         [ -  + ]:          58 :         if (!gjs_arg_get<void*>(arg))
    2913                 :           0 :             return false;
    2914                 :             :     }
    2915                 :             : 
    2916                 :        1934 :     return true;
    2917                 :             : }
    2918                 :             : 
    2919                 :             : // Overrides GIWrapperInstance::typecheck_impl()
    2920                 :        1998 : bool ObjectInstance::typecheck_impl(JSContext* cx, GIBaseInfo* expected_info,
    2921                 :             :                                     GType expected_type) const {
    2922                 :        1998 :     g_assert(m_gobj_disposed || !m_ptr ||
    2923                 :             :              gtype() == G_OBJECT_TYPE(m_ptr.as<GObject*>()));
    2924                 :        1998 :     return GIWrapperInstance::typecheck_impl(cx, expected_info, expected_type);
    2925                 :             : }
    2926                 :             : 
    2927                 :             : GJS_JSAPI_RETURN_CONVENTION
    2928                 :          59 : static bool find_vfunc_info(JSContext* context, GType implementor_gtype,
    2929                 :             :                             GIBaseInfo* vfunc_info, const char* vfunc_name,
    2930                 :             :                             void** implementor_vtable_ret,
    2931                 :             :                             GjsAutoFieldInfo* field_info_ret) {
    2932                 :             :     GType ancestor_gtype;
    2933                 :             :     int length, i;
    2934                 :             :     GIBaseInfo *ancestor_info;
    2935                 :          59 :     GjsAutoStructInfo struct_info;
    2936                 :             :     bool is_interface;
    2937                 :             : 
    2938                 :          59 :     field_info_ret->reset();
    2939                 :          59 :     *implementor_vtable_ret = NULL;
    2940                 :             : 
    2941                 :          59 :     ancestor_info = g_base_info_get_container(vfunc_info);
    2942                 :          59 :     ancestor_gtype = g_registered_type_info_get_g_type((GIRegisteredTypeInfo*)ancestor_info);
    2943                 :             : 
    2944                 :          59 :     is_interface = g_base_info_get_type(ancestor_info) == GI_INFO_TYPE_INTERFACE;
    2945                 :             : 
    2946                 :          59 :     GjsAutoTypeClass<GTypeClass> implementor_class(implementor_gtype);
    2947         [ +  + ]:          59 :     if (is_interface) {
    2948                 :             :         GTypeInstance *implementor_iface_class;
    2949                 :           9 :         implementor_iface_class = (GTypeInstance*) g_type_interface_peek(implementor_class,
    2950                 :             :                                                         ancestor_gtype);
    2951         [ -  + ]:           9 :         if (implementor_iface_class == NULL) {
    2952                 :           0 :             gjs_throw (context, "Couldn't find GType of implementor of interface %s.",
    2953                 :             :                        g_type_name(ancestor_gtype));
    2954                 :           0 :             return false;
    2955                 :             :         }
    2956                 :             : 
    2957                 :           9 :         *implementor_vtable_ret = implementor_iface_class;
    2958                 :             : 
    2959                 :           9 :         struct_info = g_interface_info_get_iface_struct((GIInterfaceInfo*)ancestor_info);
    2960                 :             :     } else {
    2961                 :          50 :         struct_info = g_object_info_get_class_struct((GIObjectInfo*)ancestor_info);
    2962                 :          50 :         *implementor_vtable_ret = implementor_class;
    2963                 :             :     }
    2964                 :             : 
    2965                 :          59 :     length = g_struct_info_get_n_fields(struct_info);
    2966         [ +  - ]:         873 :     for (i = 0; i < length; i++) {
    2967                 :         873 :         GjsAutoFieldInfo field_info = g_struct_info_get_field(struct_info, i);
    2968         [ +  + ]:         873 :         if (strcmp(field_info.name(), vfunc_name) != 0)
    2969                 :         814 :             continue;
    2970                 :             : 
    2971                 :          59 :         GjsAutoTypeInfo type_info = g_field_info_get_type(field_info);
    2972         [ -  + ]:          59 :         if (g_type_info_get_tag(type_info) != GI_TYPE_TAG_INTERFACE) {
    2973                 :             :             /* We have a field with the same name, but it's not a callback.
    2974                 :             :              * There's no hope of being another field with a correct name,
    2975                 :             :              * so just abort early. */
    2976                 :           0 :             return true;
    2977                 :             :         } else {
    2978                 :          59 :             *field_info_ret = std::move(field_info);
    2979                 :          59 :             return true;
    2980                 :             :         }
    2981         [ +  + ]:         932 :     }
    2982                 :           0 :     return true;
    2983                 :          59 : }
    2984                 :             : 
    2985                 :          62 : bool ObjectBase::hook_up_vfunc(JSContext* cx, unsigned argc, JS::Value* vp) {
    2986   [ -  +  -  + ]:          62 :     GJS_CHECK_WRAPPER_PRIV(cx, argc, vp, args, prototype, ObjectBase, priv);
    2987                 :             :     /* Normally we wouldn't assert is_prototype(), but this method can only be
    2988                 :             :      * called internally so it's OK to crash if done wrongly */
    2989                 :          62 :     return priv->to_prototype()->hook_up_vfunc_impl(cx, args);
    2990                 :          62 : }
    2991                 :             : 
    2992                 :          62 : bool ObjectPrototype::hook_up_vfunc_impl(JSContext* cx,
    2993                 :             :                                          const JS::CallArgs& args) {
    2994                 :          62 :     JS::UniqueChars name;
    2995                 :          62 :     JS::RootedObject callable(cx);
    2996         [ -  + ]:          62 :     if (!gjs_parse_call_args(cx, "hook_up_vfunc", args, "so", "name", &name,
    2997                 :             :                              "callable", &callable))
    2998                 :           0 :         return false;
    2999                 :             : 
    3000                 :          62 :     args.rval().setUndefined();
    3001                 :             : 
    3002                 :             :     /* find the first class that actually has repository information */
    3003                 :          62 :     GIObjectInfo *info = m_info;
    3004                 :          62 :     GType info_gtype = m_gtype;
    3005   [ +  +  +  - ]:         129 :     while (!info && info_gtype != G_TYPE_OBJECT) {
    3006                 :          67 :         info_gtype = g_type_parent(info_gtype);
    3007                 :             : 
    3008                 :          67 :         info = g_irepository_find_by_gtype(nullptr, info_gtype);
    3009                 :             :     }
    3010                 :             : 
    3011                 :             :     /* If we don't have 'info', we don't have the base class (GObject).
    3012                 :             :      * This is awful, so abort now. */
    3013                 :          62 :     g_assert(info != NULL);
    3014                 :             : 
    3015                 :          62 :     GjsAutoVFuncInfo vfunc = g_object_info_find_vfunc(info, name.get());
    3016                 :             :     // Search the parent type chain
    3017   [ +  +  +  +  :          68 :     while (!vfunc && info_gtype != G_TYPE_OBJECT) {
                   +  + ]
    3018                 :           6 :         info_gtype = g_type_parent(info_gtype);
    3019                 :             : 
    3020                 :           6 :         info = g_irepository_find_by_gtype(nullptr, info_gtype);
    3021         [ +  - ]:           6 :         if (info)
    3022                 :           6 :             vfunc = g_object_info_find_vfunc(info, name.get());
    3023                 :             :     }
    3024                 :             : 
    3025                 :             :     // If the vfunc doesn't exist in the parent
    3026                 :             :     // type chain, loop through the explicitly
    3027                 :             :     // defined interfaces...
    3028         [ +  + ]:          62 :     if (!vfunc) {
    3029         [ +  + ]:          12 :         for (GType interface_gtype : m_interface_gtypes) {
    3030                 :             :             GjsAutoInterfaceInfo interface =
    3031                 :           9 :                 g_irepository_find_by_gtype(nullptr, interface_gtype);
    3032                 :             : 
    3033                 :             :             // Private and dynamic interfaces (defined in JS) do not have type
    3034                 :             :             // info.
    3035         [ +  - ]:           9 :             if (interface) {
    3036                 :           9 :                 vfunc = g_interface_info_find_vfunc(interface, name.get());
    3037                 :             : 
    3038         [ +  - ]:           9 :                 if (vfunc)
    3039                 :           9 :                     break;
    3040                 :             :             }
    3041         [ -  + ]:           9 :         }
    3042                 :             :     }
    3043                 :             : 
    3044                 :             :     // If the vfunc is still not found, it could exist on an interface
    3045                 :             :     // implemented by a parent. This is an error, as hooking up the vfunc
    3046                 :             :     // would create an implementation on the interface itself. In this
    3047                 :             :     // case, print a more helpful error than...
    3048                 :             :     // "Could not find definition of virtual function"
    3049                 :             :     //
    3050                 :             :     // See https://gitlab.gnome.org/GNOME/gjs/-/issues/89
    3051         [ +  + ]:          62 :     if (!vfunc) {
    3052                 :             :         unsigned n_interfaces;
    3053                 :             :         GjsAutoPointer<GType> interface_list =
    3054                 :           3 :             g_type_interfaces(m_gtype, &n_interfaces);
    3055                 :             : 
    3056         [ +  + ]:           3 :         for (unsigned i = 0; i < n_interfaces; i++) {
    3057                 :             :             GjsAutoInterfaceInfo interface =
    3058                 :           2 :                 g_irepository_find_by_gtype(nullptr, interface_list[i]);
    3059                 :             : 
    3060         [ +  - ]:           2 :             if (interface) {
    3061                 :             :                 GjsAutoVFuncInfo parent_vfunc =
    3062                 :           2 :                     g_interface_info_find_vfunc(interface, name.get());
    3063                 :             : 
    3064         [ +  - ]:           2 :                 if (parent_vfunc) {
    3065                 :             :                     GjsAutoChar identifier = g_strdup_printf(
    3066                 :           2 :                         "%s.%s", interface.ns(), interface.name());
    3067                 :           2 :                     gjs_throw(cx,
    3068                 :             :                               "%s does not implement %s, add %s to your "
    3069                 :             :                               "implements array",
    3070                 :             :                               g_type_name(m_gtype), identifier.get(),
    3071                 :             :                               identifier.get());
    3072                 :           2 :                     return false;
    3073                 :           2 :                 }
    3074         [ -  + ]:           2 :             }
    3075         [ -  + ]:           2 :         }
    3076                 :             : 
    3077                 :             :         // Fall back to less helpful error message
    3078                 :           1 :         gjs_throw(cx, "Could not find definition of virtual function %s",
    3079                 :             :                   name.get());
    3080                 :           1 :         return false;
    3081                 :           3 :     }
    3082                 :             : 
    3083                 :             :     void *implementor_vtable;
    3084                 :          59 :     GjsAutoFieldInfo field_info;
    3085         [ -  + ]:          59 :     if (!find_vfunc_info(cx, m_gtype, vfunc, name.get(), &implementor_vtable,
    3086                 :             :                          &field_info))
    3087                 :           0 :         return false;
    3088                 :             : 
    3089         [ +  - ]:          59 :     if (field_info) {
    3090                 :             :         gint offset;
    3091                 :             :         void* method_ptr;
    3092                 :             :         GjsCallbackTrampoline *trampoline;
    3093                 :             : 
    3094                 :          59 :         offset = g_field_info_get_offset(field_info);
    3095                 :          59 :         method_ptr = G_STRUCT_MEMBER_P(implementor_vtable, offset);
    3096                 :             : 
    3097         [ -  + ]:          59 :         if (!JS::IsCallable(callable)) {
    3098                 :           0 :             gjs_throw(cx, "Tried to deal with a vfunc that wasn't callable");
    3099                 :           1 :             return false;
    3100                 :             :         }
    3101                 :          59 :         trampoline = GjsCallbackTrampoline::create(
    3102                 :             :             cx, callable, vfunc, GI_SCOPE_TYPE_NOTIFIED, true, true);
    3103         [ +  + ]:          59 :         if (!trampoline)
    3104                 :           1 :             return false;
    3105                 :             : 
    3106                 :             :         // This is traced, and will be cleared from the list when the closure is
    3107                 :             :         // invalidated
    3108                 :          58 :         g_assert(std::find(m_vfuncs.begin(), m_vfuncs.end(), trampoline) ==
    3109                 :             :                      m_vfuncs.end() &&
    3110                 :             :                  "This vfunc was already associated with this class");
    3111                 :          58 :         m_vfuncs.push_back(trampoline);
    3112                 :          58 :         g_closure_add_invalidate_notifier(
    3113                 :             :             trampoline, this, &ObjectPrototype::vfunc_invalidated_notify);
    3114                 :          58 :         g_closure_add_invalidate_notifier(
    3115                 :             :             trampoline, nullptr,
    3116                 :          58 :             [](void*, GClosure* closure) { g_closure_unref(closure); });
    3117                 :             : 
    3118                 :          58 :         *reinterpret_cast<void**>(method_ptr) = trampoline->closure();
    3119                 :             :     }
    3120                 :             : 
    3121                 :          58 :     return true;
    3122                 :          62 : }
    3123                 :             : 
    3124                 :           0 : void ObjectPrototype::vfunc_invalidated_notify(void* data, GClosure* closure) {
    3125                 :             :     // This callback should *only* touch m_vfuncs
    3126                 :           0 :     auto* priv = static_cast<ObjectPrototype*>(data);
    3127                 :           0 :     Gjs::remove_one_from_unsorted_vector(&priv->m_vfuncs, closure);
    3128                 :           0 : }
    3129                 :             : 
    3130                 :             : bool
    3131                 :         519 : gjs_lookup_object_constructor(JSContext             *context,
    3132                 :             :                               GType                  gtype,
    3133                 :             :                               JS::MutableHandleValue value_p)
    3134                 :             : {
    3135                 :             :     JSObject *constructor;
    3136                 :             : 
    3137                 :         519 :     GjsAutoObjectInfo object_info = gjs_lookup_gtype(nullptr, gtype);
    3138                 :             : 
    3139                 :         519 :     constructor = gjs_lookup_object_constructor_from_info(context, object_info, gtype);
    3140                 :             : 
    3141         [ -  + ]:         519 :     if (G_UNLIKELY (constructor == NULL))
    3142                 :           0 :         return false;
    3143                 :             : 
    3144                 :         519 :     value_p.setObject(*constructor);
    3145                 :         519 :     return true;
    3146                 :         519 : }
    3147                 :             : 
    3148                 :           2 : void ObjectInstance::associate_string(GObject* obj, char* str) {
    3149                 :             :     auto* instance_strings = static_cast<GPtrArray*>(
    3150                 :           2 :         g_object_get_qdata(obj, ObjectBase::instance_strings_quark()));
    3151                 :             : 
    3152         [ +  + ]:           2 :     if (!instance_strings) {
    3153                 :           1 :         instance_strings = g_ptr_array_new_with_free_func(g_free);
    3154                 :           1 :         g_object_set_qdata_full(
    3155                 :             :             obj, ObjectBase::instance_strings_quark(), instance_strings,
    3156                 :             :             reinterpret_cast<GDestroyNotify>(g_ptr_array_unref));
    3157                 :             :     }
    3158                 :           2 :     g_ptr_array_add(instance_strings, str);
    3159                 :           2 : }
        

Generated by: LCOV version 2.0-1