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