LCOV - code coverage report
Current view: top level - gjs - context.cpp (source / functions) Hit Total Coverage
Test: gjs- Code Coverage Lines: 710 872 81.4 %
Date: 2024-02-27 17:05:05 Functions: 80 92 87.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 222 350 63.4 %

           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                 :            : 
       5                 :            : #include <config.h>
       6                 :            : 
       7                 :            : #include <signal.h>  // for sigaction, SIGUSR1, sa_handler
       8                 :            : #include <stdint.h>
       9                 :            : #include <stdio.h>   // for FILE, fclose, size_t
      10                 :            : #include <stdlib.h>  // for exit
      11                 :            : #include <string.h>  // for memset
      12                 :            : 
      13                 :            : #ifdef HAVE_UNISTD_H
      14                 :            : #    include <unistd.h>  // for getpid
      15                 :            : #elif defined (_WIN32)
      16                 :            : #    include <process.h>
      17                 :            : #endif
      18                 :            : 
      19                 :            : #ifdef DEBUG
      20                 :            : #    include <algorithm>  // for find
      21                 :            : #endif
      22                 :            : #include <new>
      23                 :            : #include <string>       // for u16string
      24                 :            : #include <thread>       // for get_id
      25                 :            : #include <unordered_map>
      26                 :            : #include <utility>  // for move
      27                 :            : #include <vector>
      28                 :            : 
      29                 :            : #include <gio/gio.h>
      30                 :            : #include <girepository.h>
      31                 :            : #include <glib-object.h>
      32                 :            : #include <glib.h>
      33                 :            : 
      34                 :            : #ifdef G_OS_WIN32
      35                 :            : #include <windows.h>
      36                 :            : #endif
      37                 :            : 
      38                 :            : #include <js/AllocPolicy.h>  // for SystemAllocPolicy
      39                 :            : #include <js/CallAndConstruct.h>  // for Call, JS_CallFunctionValue
      40                 :            : #include <js/CallArgs.h>     // for UndefinedHandleValue
      41                 :            : #include <js/CharacterEncoding.h>
      42                 :            : #include <js/CompilationAndEvaluation.h>
      43                 :            : #include <js/CompileOptions.h>
      44                 :            : #include <js/Context.h>
      45                 :            : #include <js/ErrorReport.h>
      46                 :            : #include <js/Exception.h>           // for StealPendingExceptionStack
      47                 :            : #include <js/GCAPI.h>               // for JS_GC, JS_AddExtraGCRootsTr...
      48                 :            : #include <js/GCHashTable.h>         // for WeakCache
      49                 :            : #include <js/GCVector.h>            // for RootedVector
      50                 :            : #include <js/GlobalObject.h>        // for CurrentGlobalOrNull
      51                 :            : #include <js/HashTable.h>           // for DefaultHasher via WeakCache
      52                 :            : #include <js/HeapAPI.h>             // for ExposeObjectToActiveJS
      53                 :            : #include <js/Id.h>
      54                 :            : #include <js/Modules.h>
      55                 :            : #include <js/Promise.h>             // for JobQueue::SavedJobQueue
      56                 :            : #include <js/PropertyAndElement.h>
      57                 :            : #include <js/PropertyDescriptor.h>  // for JSPROP_PERMANENT, JSPROP_RE...
      58                 :            : #include <js/Realm.h>
      59                 :            : #include <js/RootingAPI.h>
      60                 :            : #include <js/ScriptPrivate.h>
      61                 :            : #include <js/SourceText.h>
      62                 :            : #include <js/TracingAPI.h>
      63                 :            : #include <js/TypeDecls.h>
      64                 :            : #include <js/UniquePtr.h>
      65                 :            : #include <js/Utility.h>  // for DeletePolicy via WeakCache
      66                 :            : #include <js/Value.h>
      67                 :            : #include <js/ValueArray.h>
      68                 :            : #include <js/friend/DumpFunctions.h>
      69                 :            : #include <jsapi.h>        // for JS_GetFunctionObject, JS_Ge...
      70                 :            : #include <jsfriendapi.h>  // for ScriptEnvironmentPreparer
      71                 :            : #include <mozilla/UniquePtr.h>  // for UniquePtr::get
      72                 :            : 
      73                 :            : #include "gi/closure.h"  // for Closure::Ptr, Closure
      74                 :            : #include "gi/function.h"
      75                 :            : #include "gi/object.h"
      76                 :            : #include "gi/private.h"
      77                 :            : #include "gi/repo.h"
      78                 :            : #include "gi/utils-inl.h"
      79                 :            : #include "gjs/atoms.h"
      80                 :            : #include "gjs/byteArray.h"
      81                 :            : #include "gjs/context-private.h"
      82                 :            : #include "gjs/context.h"
      83                 :            : #include "gjs/engine.h"
      84                 :            : #include "gjs/error-types.h"
      85                 :            : #include "gjs/global.h"
      86                 :            : #include "gjs/importer.h"
      87                 :            : #include "gjs/internal.h"
      88                 :            : #include "gjs/jsapi-util.h"
      89                 :            : #include "gjs/mainloop.h"
      90                 :            : #include "gjs/mem.h"
      91                 :            : #include "gjs/module.h"
      92                 :            : #include "gjs/native.h"
      93                 :            : #include "gjs/objectbox.h"
      94                 :            : #include "gjs/profiler-private.h"
      95                 :            : #include "gjs/profiler.h"
      96                 :            : #include "gjs/promise.h"
      97                 :            : #include "gjs/text-encoding.h"
      98                 :            : #include "modules/console.h"
      99                 :            : #include "modules/print.h"
     100                 :            : #include "modules/system.h"
     101                 :            : #include "util/log.h"
     102                 :            : #ifdef ENABLE_CAIRO
     103                 :            : #    include "modules/cairo-module.h"
     104                 :            : #endif
     105                 :            : 
     106                 :            : namespace mozilla {
     107                 :            : union Utf8Unit;
     108                 :            : }
     109                 :            : 
     110                 :            : static void     gjs_context_dispose           (GObject               *object);
     111                 :            : static void     gjs_context_finalize          (GObject               *object);
     112                 :            : static void     gjs_context_constructed       (GObject               *object);
     113                 :            : static void     gjs_context_get_property      (GObject               *object,
     114                 :            :                                                   guint                  prop_id,
     115                 :            :                                                   GValue                *value,
     116                 :            :                                                   GParamSpec            *pspec);
     117                 :            : static void     gjs_context_set_property      (GObject               *object,
     118                 :            :                                                   guint                  prop_id,
     119                 :            :                                                   const GValue          *value,
     120                 :            :                                                   GParamSpec            *pspec);
     121                 :            : 
     122                 :          0 : void GjsContextPrivate::EnvironmentPreparer::invoke(JS::HandleObject scope,
     123                 :            :                                                     Closure& closure) {
     124                 :          0 :     g_assert(!JS_IsExceptionPending(m_cx));
     125                 :            : 
     126                 :          0 :     JSAutoRealm ar(m_cx, scope);
     127         [ #  # ]:          0 :     if (!closure(m_cx))
     128                 :          0 :         gjs_log_exception(m_cx);
     129                 :          0 : }
     130                 :            : 
     131                 :            : struct _GjsContext {
     132                 :            :     GObject parent;
     133                 :            : };
     134                 :            : 
     135   [ +  +  +  -  :      23829 : G_DEFINE_TYPE_WITH_PRIVATE(GjsContext, gjs_context, G_TYPE_OBJECT);
                   +  + ]
     136                 :            : 
     137                 :       2174 : GjsContextPrivate* GjsContextPrivate::from_object(GObject* js_context) {
     138                 :       2174 :     g_return_val_if_fail(GJS_IS_CONTEXT(js_context), nullptr);
     139                 :            :     return static_cast<GjsContextPrivate*>(
     140                 :       2174 :         gjs_context_get_instance_private(GJS_CONTEXT(js_context)));
     141                 :            : }
     142                 :            : 
     143                 :       7153 : GjsContextPrivate* GjsContextPrivate::from_object(GjsContext* js_context) {
     144                 :       7153 :     g_return_val_if_fail(GJS_IS_CONTEXT(js_context), nullptr);
     145                 :            :     return static_cast<GjsContextPrivate*>(
     146                 :       7153 :         gjs_context_get_instance_private(js_context));
     147                 :            : }
     148                 :            : 
     149                 :       4969 : GjsContextPrivate* GjsContextPrivate::from_current_context() {
     150                 :       4969 :     return from_object(gjs_context_get_current());
     151                 :            : }
     152                 :            : 
     153                 :            : enum {
     154                 :            :     PROP_CONTEXT_0,
     155                 :            :     PROP_PROGRAM_PATH,
     156                 :            :     PROP_SEARCH_PATH,
     157                 :            :     PROP_PROGRAM_NAME,
     158                 :            :     PROP_PROFILER_ENABLED,
     159                 :            :     PROP_PROFILER_SIGUSR2,
     160                 :            :     PROP_EXEC_AS_MODULE,
     161                 :            : };
     162                 :            : 
     163                 :            : static GMutex contexts_lock;
     164                 :            : static GList *all_contexts = NULL;
     165                 :            : 
     166                 :            : static GjsAutoChar dump_heap_output;
     167                 :            : static unsigned dump_heap_idle_id = 0;
     168                 :            : 
     169                 :            : #ifdef G_OS_UNIX
     170                 :            : // Currently heap dumping via SIGUSR1 is only supported on UNIX platforms!
     171                 :            : // This can reduce performance. See note in system.cpp on System.dumpHeap().
     172                 :            : static void
     173                 :          0 : gjs_context_dump_heaps(void)
     174                 :            : {
     175                 :            :     static unsigned counter = 0;
     176                 :            : 
     177                 :          0 :     gjs_memory_report("signal handler", false);
     178                 :            : 
     179                 :            :     /* dump to sequential files to allow easier comparisons */
     180                 :            :     GjsAutoChar filename = g_strdup_printf("%s.%jd.%u", dump_heap_output.get(),
     181                 :          0 :                                            intmax_t(getpid()), counter);
     182                 :          0 :     ++counter;
     183                 :            : 
     184                 :          0 :     FILE *fp = fopen(filename, "w");
     185         [ #  # ]:          0 :     if (!fp)
     186                 :          0 :         return;
     187                 :            : 
     188   [ #  #  #  # ]:          0 :     for (GList *l = all_contexts; l; l = g_list_next(l)) {
     189                 :          0 :         auto* gjs = static_cast<GjsContextPrivate*>(l->data);
     190                 :          0 :         js::DumpHeap(gjs->context(), fp, js::CollectNurseryBeforeDump);
     191                 :            :     }
     192                 :            : 
     193                 :          0 :     fclose(fp);
     194         [ #  # ]:          0 : }
     195                 :            : 
     196                 :          0 : static gboolean dump_heap_idle(void*) {
     197                 :          0 :     dump_heap_idle_id = 0;
     198                 :            : 
     199                 :          0 :     gjs_context_dump_heaps();
     200                 :            : 
     201                 :          0 :     return false;
     202                 :            : }
     203                 :            : 
     204                 :          0 : static void dump_heap_signal_handler(int signum [[maybe_unused]]) {
     205         [ #  # ]:          0 :     if (dump_heap_idle_id == 0)
     206                 :          0 :         dump_heap_idle_id = g_idle_add_full(G_PRIORITY_HIGH_IDLE,
     207                 :            :                                             dump_heap_idle, nullptr, nullptr);
     208                 :          0 : }
     209                 :            : #endif
     210                 :            : 
     211                 :            : static void
     212                 :        242 : setup_dump_heap(void)
     213                 :            : {
     214                 :            :     static bool dump_heap_initialized = false;
     215         [ +  + ]:        242 :     if (!dump_heap_initialized) {
     216                 :        103 :         dump_heap_initialized = true;
     217                 :            : 
     218                 :            :         /* install signal handler only if environment variable is set */
     219                 :        103 :         const char *heap_output = g_getenv("GJS_DEBUG_HEAP_OUTPUT");
     220         [ -  + ]:        103 :         if (heap_output) {
     221                 :            : #ifdef G_OS_UNIX
     222                 :            :             struct sigaction sa;
     223                 :            : 
     224                 :          0 :             dump_heap_output = g_strdup(heap_output);
     225                 :            : 
     226                 :          0 :             memset(&sa, 0, sizeof(sa));
     227                 :          0 :             sa.sa_handler = dump_heap_signal_handler;
     228                 :          0 :             sigaction(SIGUSR1, &sa, nullptr);
     229                 :            : #else
     230                 :            :             g_message(
     231                 :            :                 "heap dump is currently only supported on UNIX platforms");
     232                 :            : #endif
     233                 :            :         }
     234                 :            :     }
     235                 :        242 : }
     236                 :            : 
     237                 :            : static void
     238                 :        242 : gjs_context_init(GjsContext *js_context)
     239                 :            : {
     240                 :        242 :     gjs_log_init();
     241                 :        242 :     gjs_context_make_current(js_context);
     242                 :        242 : }
     243                 :            : 
     244                 :            : static void
     245                 :        103 : gjs_context_class_init(GjsContextClass *klass)
     246                 :            : {
     247                 :        103 :     GObjectClass *object_class = G_OBJECT_CLASS (klass);
     248                 :            :     GParamSpec *pspec;
     249                 :            : 
     250                 :        103 :     gjs_log_init();
     251                 :            : 
     252                 :        103 :     object_class->dispose = gjs_context_dispose;
     253                 :        103 :     object_class->finalize = gjs_context_finalize;
     254                 :            : 
     255                 :        103 :     object_class->constructed = gjs_context_constructed;
     256                 :        103 :     object_class->get_property = gjs_context_get_property;
     257                 :        103 :     object_class->set_property = gjs_context_set_property;
     258                 :            : 
     259                 :        103 :     pspec = g_param_spec_boxed("search-path",
     260                 :            :                                "Search path",
     261                 :            :                                "Path where modules to import should reside",
     262                 :            :                                G_TYPE_STRV,
     263                 :            :                                (GParamFlags) (G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
     264                 :            : 
     265                 :        103 :     g_object_class_install_property(object_class,
     266                 :            :                                     PROP_SEARCH_PATH,
     267                 :            :                                     pspec);
     268                 :        103 :     g_param_spec_unref(pspec);
     269                 :            : 
     270                 :        103 :     pspec = g_param_spec_string("program-name",
     271                 :            :                                 "Program Name",
     272                 :            :                                 "The filename of the launched JS program",
     273                 :            :                                 "",
     274                 :            :                                 (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
     275                 :            : 
     276                 :        103 :     g_object_class_install_property(object_class,
     277                 :            :                                     PROP_PROGRAM_NAME,
     278                 :            :                                     pspec);
     279                 :        103 :     g_param_spec_unref(pspec);
     280                 :            : 
     281                 :        103 :     pspec = g_param_spec_string(
     282                 :            :         "program-path", "Executed File Path",
     283                 :            :         "The full path of the launched file or NULL if GJS was launched from "
     284                 :            :         "the C API or interactive console.",
     285                 :            :         nullptr, (GParamFlags)(G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
     286                 :            : 
     287                 :        103 :     g_object_class_install_property(object_class, PROP_PROGRAM_PATH, pspec);
     288                 :        103 :     g_param_spec_unref(pspec);
     289                 :            : 
     290                 :            :     /**
     291                 :            :      * GjsContext:profiler-enabled:
     292                 :            :      *
     293                 :            :      * Set this property to profile any JS code run by this context. By
     294                 :            :      * default, the profiler is started and stopped when you call
     295                 :            :      * gjs_context_eval().
     296                 :            :      *
     297                 :            :      * The value of this property is superseded by the GJS_ENABLE_PROFILER
     298                 :            :      * environment variable.
     299                 :            :      *
     300                 :            :      * You may only have one context with the profiler enabled at a time.
     301                 :            :      */
     302                 :        103 :     pspec = g_param_spec_boolean("profiler-enabled", "Profiler enabled",
     303                 :            :                                  "Whether to profile JS code run by this context",
     304                 :            :                                  FALSE,
     305                 :            :                                  GParamFlags(G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
     306                 :        103 :     g_object_class_install_property(object_class, PROP_PROFILER_ENABLED, pspec);
     307                 :        103 :     g_param_spec_unref(pspec);
     308                 :            : 
     309                 :            :     /**
     310                 :            :      * GjsContext:profiler-sigusr2:
     311                 :            :      *
     312                 :            :      * Set this property to install a SIGUSR2 signal handler that starts and
     313                 :            :      * stops the profiler. This property also implies that
     314                 :            :      * #GjsContext:profiler-enabled is set.
     315                 :            :      */
     316                 :        103 :     pspec = g_param_spec_boolean("profiler-sigusr2", "Profiler SIGUSR2",
     317                 :            :                                  "Whether to activate the profiler on SIGUSR2",
     318                 :            :                                  FALSE,
     319                 :            :                                  GParamFlags(G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
     320                 :        103 :     g_object_class_install_property(object_class, PROP_PROFILER_SIGUSR2, pspec);
     321                 :        103 :     g_param_spec_unref(pspec);
     322                 :            : 
     323                 :        103 :     pspec = g_param_spec_boolean(
     324                 :            :         "exec-as-module", "Execute as module",
     325                 :            :         "Whether to execute the file as a module", FALSE,
     326                 :            :         GParamFlags(G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
     327                 :        103 :     g_object_class_install_property(object_class, PROP_EXEC_AS_MODULE, pspec);
     328                 :        103 :     g_param_spec_unref(pspec);
     329                 :            : 
     330                 :            :     /* For GjsPrivate */
     331         [ -  + ]:        103 :     if (!g_getenv("GJS_USE_UNINSTALLED_FILES")) {
     332                 :            : #ifdef G_OS_WIN32
     333                 :            :         extern HMODULE gjs_dll;
     334                 :            :         GjsAutoChar basedir =
     335                 :            :             g_win32_get_package_installation_directory_of_module(gjs_dll);
     336                 :            :         GjsAutoChar priv_typelib_dir = g_build_filename(
     337                 :            :             basedir, "lib", "gjs", "girepository-1.0", nullptr);
     338                 :            : #else
     339                 :            :         GjsAutoChar priv_typelib_dir =
     340                 :          0 :             g_build_filename(PKGLIBDIR, "girepository-1.0", nullptr);
     341                 :            : #endif
     342                 :          0 :         g_irepository_prepend_search_path(priv_typelib_dir);
     343                 :          0 :     }
     344                 :        103 :     auto& registry = Gjs::NativeModuleDefineFuncs::get();
     345                 :        103 :     registry.add("_promiseNative", gjs_define_native_promise_stuff);
     346                 :        103 :     registry.add("_byteArrayNative", gjs_define_byte_array_stuff);
     347                 :        103 :     registry.add("_encodingNative", gjs_define_text_encoding_stuff);
     348                 :        103 :     registry.add("_gi", gjs_define_private_gi_stuff);
     349                 :        103 :     registry.add("gi", gjs_define_repo);
     350                 :            : #ifdef ENABLE_CAIRO
     351                 :        103 :     registry.add("cairoNative", gjs_js_define_cairo_stuff);
     352                 :            : #endif
     353                 :        103 :     registry.add("system", gjs_js_define_system_stuff);
     354                 :        103 :     registry.add("console", gjs_define_console_stuff);
     355                 :        103 :     registry.add("_print", gjs_define_print_stuff);
     356                 :        103 : }
     357                 :            : 
     358                 :        323 : void GjsContextPrivate::trace(JSTracer* trc, void* data) {
     359                 :        323 :     auto* gjs = static_cast<GjsContextPrivate*>(data);
     360                 :        323 :     JS::TraceEdge<JSObject*>(trc, &gjs->m_global, "GJS global object");
     361                 :        323 :     JS::TraceEdge<JSObject*>(trc, &gjs->m_internal_global,
     362                 :            :                              "GJS internal global object");
     363                 :        323 :     JS::TraceEdge<JSObject*>(trc, &gjs->m_main_loop_hook, "GJS main loop hook");
     364                 :        323 :     gjs->m_atoms->trace(trc);
     365                 :        323 :     gjs->m_job_queue.trace(trc);
     366                 :        323 :     gjs->m_cleanup_tasks.trace(trc);
     367                 :        323 :     gjs->m_object_init_list.trace(trc);
     368                 :        323 : }
     369                 :            : 
     370                 :       8681 : void GjsContextPrivate::warn_about_unhandled_promise_rejections(void) {
     371         [ +  + ]:       8682 :     for (auto& kv : m_unhandled_rejection_stacks) {
     372                 :          1 :         const char* stack = kv.second.get();
     373   [ +  -  +  - ]:          1 :         g_warning("Unhandled promise rejection. To suppress this warning, add "
     374                 :            :                   "an error handler to your promise chain with .catch() or a "
     375                 :            :                   "try-catch block around your await expression. %s%s",
     376                 :            :                   stack ? "Stack trace of the failed promise:\n" :
     377                 :            :                     "Unfortunately there is no stack trace of the failed promise.",
     378                 :            :                   stack ? stack : "");
     379                 :            :     }
     380                 :       8681 :     m_unhandled_rejection_stacks.clear();
     381                 :       8681 : }
     382                 :            : 
     383                 :            : static void
     384                 :        240 : gjs_context_dispose(GObject *object)
     385                 :            : {
     386                 :        240 :     gjs_debug(GJS_DEBUG_CONTEXT, "JS shutdown sequence");
     387                 :            : 
     388                 :        240 :     GjsContextPrivate* gjs = GjsContextPrivate::from_object(object);
     389                 :            : 
     390                 :        240 :     g_assert(gjs->is_owner_thread() &&
     391                 :            :              "Gjs Context disposed from another thread");
     392                 :            : 
     393                 :            :     /* Profiler must be stopped and freed before context is shut down */
     394                 :        240 :     gjs->free_profiler();
     395                 :            : 
     396                 :            :     /* Stop accepting entries in the toggle queue before running dispose
     397                 :            :      * notifications, which causes all GjsMaybeOwned instances to unroot.
     398                 :            :      * We don't want any objects to toggle down after that. */
     399                 :        240 :     gjs_debug(GJS_DEBUG_CONTEXT, "Shutting down toggle queue");
     400                 :        240 :     gjs_object_clear_toggles();
     401                 :        240 :     gjs_object_shutdown_toggle_queue();
     402                 :            : 
     403         [ +  - ]:        240 :     if (gjs->context())
     404                 :        240 :         ObjectInstance::context_dispose_notify(nullptr, object);
     405                 :            : 
     406                 :        240 :     gjs_debug(GJS_DEBUG_CONTEXT,
     407                 :            :               "Notifying external reference holders of GjsContext dispose");
     408                 :        240 :     G_OBJECT_CLASS(gjs_context_parent_class)->dispose(object);
     409                 :            : 
     410                 :        240 :     gjs->dispose();
     411                 :        240 : }
     412                 :            : 
     413                 :        240 : void GjsContextPrivate::free_profiler(void) {
     414                 :        240 :     gjs_debug(GJS_DEBUG_CONTEXT, "Stopping profiler");
     415         [ +  + ]:        240 :     if (m_profiler)
     416         [ +  - ]:          5 :         g_clear_pointer(&m_profiler, _gjs_profiler_free);
     417                 :        240 : }
     418                 :            : 
     419                 :      11654 : void GjsContextPrivate::register_notifier(DestroyNotify notify_func,
     420                 :            :                                           void* data) {
     421                 :      11654 :     m_destroy_notifications.push_back({notify_func, data});
     422                 :      11654 : }
     423                 :            : 
     424                 :      11466 : void GjsContextPrivate::unregister_notifier(DestroyNotify notify_func,
     425                 :            :                                             void* data) {
     426                 :      11466 :     auto target = std::make_pair(notify_func, data);
     427                 :      11466 :     Gjs::remove_one_from_unsorted_vector(&m_destroy_notifications, target);
     428                 :      11466 : }
     429                 :            : 
     430                 :        240 : void GjsContextPrivate::dispose(void) {
     431         [ +  - ]:        240 :     if (m_cx) {
     432                 :        240 :         stop_draining_job_queue();
     433                 :            : 
     434                 :        240 :         gjs_debug(GJS_DEBUG_CONTEXT,
     435                 :            :                   "Notifying reference holders of GjsContext dispose");
     436                 :            : 
     437         [ +  + ]:        425 :         for (auto const& destroy_notify : m_destroy_notifications)
     438                 :        185 :             destroy_notify.first(m_cx, destroy_notify.second);
     439                 :            : 
     440                 :        240 :         gjs_debug(GJS_DEBUG_CONTEXT,
     441                 :            :                   "Checking unhandled promise rejections");
     442                 :        240 :         warn_about_unhandled_promise_rejections();
     443                 :            : 
     444                 :        240 :         gjs_debug(GJS_DEBUG_CONTEXT, "Releasing cached JS wrappers");
     445                 :        240 :         m_fundamental_table->clear();
     446                 :        240 :         m_gtype_table->clear();
     447                 :            : 
     448                 :            :         /* Do a full GC here before tearing down, since once we do
     449                 :            :          * that we may not have the JS::GetReservedSlot(, 0) to access the
     450                 :            :          * context
     451                 :            :          */
     452                 :        240 :         gjs_debug(GJS_DEBUG_CONTEXT, "Final triggered GC");
     453                 :        240 :         JS_GC(m_cx, Gjs::GCReason::GJS_CONTEXT_DISPOSE);
     454                 :            : 
     455                 :        240 :         gjs_debug(GJS_DEBUG_CONTEXT, "Destroying JS context");
     456                 :        240 :         m_destroying.store(true);
     457                 :            : 
     458                 :            :         /* Now, release all native objects, to avoid recursion between
     459                 :            :          * the JS teardown and the C teardown.  The JSObject proxies
     460                 :            :          * still exist, but point to NULL.
     461                 :            :          */
     462                 :        240 :         gjs_debug(GJS_DEBUG_CONTEXT, "Releasing all native objects");
     463                 :        240 :         ObjectInstance::prepare_shutdown();
     464                 :        240 :         GjsCallbackTrampoline::prepare_shutdown();
     465                 :            : 
     466                 :        240 :         gjs_debug(GJS_DEBUG_CONTEXT, "Disabling auto GC");
     467         [ +  + ]:        240 :         if (m_auto_gc_id > 0) {
     468                 :        137 :             g_source_remove(m_auto_gc_id);
     469                 :        137 :             m_auto_gc_id = 0;
     470                 :            :         }
     471                 :            : 
     472                 :        240 :         gjs_debug(GJS_DEBUG_CONTEXT, "Ending trace on global object");
     473                 :        240 :         JS_RemoveExtraGCRootsTracer(m_cx, &GjsContextPrivate::trace, this);
     474                 :        240 :         m_global = nullptr;
     475                 :        240 :         m_internal_global = nullptr;
     476                 :        240 :         m_main_loop_hook = nullptr;
     477                 :            : 
     478                 :        240 :         gjs_debug(GJS_DEBUG_CONTEXT, "Freeing allocated resources");
     479         [ +  - ]:        240 :         delete m_fundamental_table;
     480         [ +  - ]:        240 :         delete m_gtype_table;
     481         [ +  - ]:        240 :         delete m_atoms;
     482                 :            : 
     483                 :        240 :         m_job_queue.clear();
     484                 :        240 :         m_object_init_list.clear();
     485                 :            : 
     486                 :            :         /* Tear down JS */
     487                 :        240 :         JS_DestroyContext(m_cx);
     488                 :        240 :         m_cx = nullptr;
     489                 :            :         // don't use g_clear_pointer() as we want the pointer intact while we
     490                 :            :         // destroy the context in case we dump stack
     491                 :        240 :         gjs_debug(GJS_DEBUG_CONTEXT, "JS context destroyed");
     492                 :            :     }
     493                 :        240 : }
     494                 :            : 
     495                 :        240 : GjsContextPrivate::~GjsContextPrivate(void) {
     496         [ +  + ]:        240 :     g_clear_pointer(&m_search_path, g_strfreev);
     497         [ +  + ]:        240 :     g_clear_pointer(&m_program_path, g_free);
     498         [ +  - ]:        240 :     g_clear_pointer(&m_program_name, g_free);
     499                 :        240 : }
     500                 :            : 
     501                 :            : static void
     502                 :        240 : gjs_context_finalize(GObject *object)
     503                 :            : {
     504         [ +  - ]:        240 :     if (gjs_context_get_current() == (GjsContext*)object)
     505                 :        240 :         gjs_context_make_current(NULL);
     506                 :            : 
     507                 :        240 :     g_mutex_lock(&contexts_lock);
     508                 :        240 :     all_contexts = g_list_remove(all_contexts, object);
     509                 :        240 :     g_mutex_unlock(&contexts_lock);
     510                 :            : 
     511                 :        240 :     GjsContextPrivate* gjs = GjsContextPrivate::from_object(object);
     512                 :        240 :     gjs->~GjsContextPrivate();
     513                 :        240 :     G_OBJECT_CLASS(gjs_context_parent_class)->finalize(object);
     514                 :            : 
     515                 :        240 :     g_mutex_lock(&contexts_lock);
     516         [ +  - ]:        240 :     if (!all_contexts)
     517                 :        240 :         gjs_log_cleanup();
     518                 :        240 :     g_mutex_unlock(&contexts_lock);
     519                 :        240 : }
     520                 :            : 
     521                 :            : static void
     522                 :        242 : gjs_context_constructed(GObject *object)
     523                 :            : {
     524                 :        242 :     GjsContext *js_context = GJS_CONTEXT(object);
     525                 :            : 
     526                 :        242 :     G_OBJECT_CLASS(gjs_context_parent_class)->constructed(object);
     527                 :            : 
     528                 :        242 :     GjsContextPrivate* gjs_location = GjsContextPrivate::from_object(object);
     529                 :        242 :     JSContext* cx = gjs_create_js_context(gjs_location);
     530         [ -  + ]:        242 :     if (!cx)
     531                 :          0 :         g_error("Failed to create javascript context");
     532                 :            : 
     533                 :        242 :     new (gjs_location) GjsContextPrivate(cx, js_context);
     534                 :            : 
     535                 :        242 :     g_mutex_lock(&contexts_lock);
     536                 :        242 :     all_contexts = g_list_prepend(all_contexts, object);
     537                 :        242 :     g_mutex_unlock(&contexts_lock);
     538                 :            : 
     539                 :        242 :     setup_dump_heap();
     540                 :        242 : }
     541                 :            : 
     542                 :          1 : static bool on_context_module_rejected_log_exception(JSContext* cx,
     543                 :            :                                                      unsigned argc,
     544                 :            :                                                      JS::Value* vp) {
     545                 :          1 :     JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
     546                 :            : 
     547                 :            :     JSString* id =
     548                 :          1 :         JS_GetFunctionDisplayId(JS_GetObjectFunction(&args.callee()));
     549                 :          1 :     gjs_debug(GJS_DEBUG_IMPORTER, "Module evaluation promise rejected: %s",
     550                 :          2 :               gjs_debug_string(id).c_str());
     551                 :            : 
     552                 :          1 :     JS::HandleValue error = args.get(0);
     553                 :            : 
     554                 :          1 :     GjsContextPrivate* gjs_cx = GjsContextPrivate::from_cx(cx);
     555                 :          1 :     gjs_cx->report_unhandled_exception();
     556                 :            : 
     557                 :          1 :     gjs_log_exception_full(cx, error, nullptr, G_LOG_LEVEL_CRITICAL);
     558                 :            : 
     559                 :          1 :     gjs_cx->main_loop_release();
     560                 :            : 
     561                 :          1 :     args.rval().setUndefined();
     562                 :          1 :     return true;
     563                 :            : }
     564                 :            : 
     565                 :        353 : static bool on_context_module_resolved(JSContext* cx, unsigned argc,
     566                 :            :                                        JS::Value* vp) {
     567                 :        353 :     JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
     568                 :            : 
     569                 :            :     JSString* id =
     570                 :        353 :         JS_GetFunctionDisplayId(JS_GetObjectFunction(&args.callee()));
     571                 :        353 :     gjs_debug(GJS_DEBUG_IMPORTER, "Module evaluation promise resolved: %s",
     572                 :        706 :               gjs_debug_string(id).c_str());
     573                 :            : 
     574                 :        353 :     args.rval().setUndefined();
     575                 :            : 
     576                 :        353 :     GjsContextPrivate::from_cx(cx)->main_loop_release();
     577                 :            : 
     578                 :        353 :     return true;
     579                 :            : }
     580                 :            : 
     581                 :        357 : static bool add_promise_reactions(JSContext* cx, JS::HandleValue promise,
     582                 :            :                                   JSNative resolve, JSNative reject,
     583                 :            :                                   const std::string& debug_tag) {
     584                 :        357 :     g_assert(promise.isObject() && "got weird value from JS::ModuleEvaluate");
     585                 :        357 :     JS::RootedObject promise_object(cx, &promise.toObject());
     586                 :            : 
     587                 :        357 :     std::string resolved_tag = debug_tag + " async resolved";
     588                 :        357 :     std::string rejected_tag = debug_tag + " async rejected";
     589                 :            : 
     590                 :            :     JS::RootedFunction on_rejected(
     591                 :            :         cx,
     592                 :        357 :         js::NewFunctionWithReserved(cx, reject, 1, 0, rejected_tag.c_str()));
     593         [ -  + ]:        357 :     if (!on_rejected)
     594                 :          0 :         return false;
     595                 :            :     JS::RootedFunction on_resolved(
     596                 :            :         cx,
     597                 :        357 :         js::NewFunctionWithReserved(cx, resolve, 1, 0, resolved_tag.c_str()));
     598         [ -  + ]:        357 :     if (!on_resolved)
     599                 :          0 :         return false;
     600                 :            : 
     601                 :        357 :     JS::RootedObject resolved(cx, JS_GetFunctionObject(on_resolved));
     602                 :        357 :     JS::RootedObject rejected(cx, JS_GetFunctionObject(on_rejected));
     603                 :            : 
     604                 :        357 :     return JS::AddPromiseReactions(cx, promise_object, resolved, rejected);
     605                 :        357 : }
     606                 :            : 
     607                 :        242 : static void load_context_module(JSContext* cx, const char* uri,
     608                 :            :                                 const char* debug_identifier) {
     609                 :        242 :     JS::RootedObject loader(cx, gjs_module_load(cx, uri, uri));
     610                 :            : 
     611         [ -  + ]:        242 :     if (!loader) {
     612                 :          0 :         gjs_log_exception(cx);
     613                 :          0 :         g_error("Failed to load %s module.", debug_identifier);
     614                 :            :     }
     615                 :            : 
     616         [ -  + ]:        242 :     if (!JS::ModuleLink(cx, loader)) {
     617                 :          0 :         gjs_log_exception(cx);
     618                 :          0 :         g_error("Failed to instantiate %s module.", debug_identifier);
     619                 :            :     }
     620                 :            : 
     621                 :        242 :     JS::RootedValue evaluation_promise(cx);
     622         [ -  + ]:        242 :     if (!JS::ModuleEvaluate(cx, loader, &evaluation_promise)) {
     623                 :          0 :         gjs_log_exception(cx);
     624                 :          0 :         g_error("Failed to evaluate %s module.", debug_identifier);
     625                 :            :     }
     626                 :            : 
     627                 :        242 :     GjsContextPrivate::from_cx(cx)->main_loop_hold();
     628                 :        242 :     bool ok = add_promise_reactions(
     629                 :            :         cx, evaluation_promise, on_context_module_resolved,
     630                 :        242 :         [](JSContext* cx, unsigned argc, JS::Value* vp) {
     631                 :          0 :             JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
     632                 :            : 
     633                 :            :             JSString* id =
     634                 :          0 :                 JS_GetFunctionDisplayId(JS_GetObjectFunction(&args.callee()));
     635                 :          0 :             gjs_debug(GJS_DEBUG_IMPORTER,
     636                 :            :                       "Module evaluation promise rejected: %s",
     637                 :          0 :                       gjs_debug_string(id).c_str());
     638                 :            : 
     639                 :          0 :             JS::HandleValue error = args.get(0);
     640                 :            :             // Abort because this module is required.
     641                 :          0 :             gjs_log_exception_full(cx, error, nullptr, G_LOG_LEVEL_ERROR);
     642                 :            : 
     643                 :          0 :             GjsContextPrivate::from_cx(cx)->main_loop_release();
     644                 :          0 :             return false;
     645                 :            :         },
     646                 :            :         debug_identifier);
     647                 :            : 
     648         [ -  + ]:        242 :     if (!ok) {
     649                 :          0 :         gjs_log_exception(cx);
     650                 :          0 :         g_error("Failed to load %s module.", debug_identifier);
     651                 :            :     }
     652                 :        242 : }
     653                 :            : 
     654                 :        242 : GjsContextPrivate::GjsContextPrivate(JSContext* cx, GjsContext* public_context)
     655                 :        242 :     : m_public_context(public_context),
     656                 :        242 :       m_cx(cx),
     657                 :        242 :       m_owner_thread(std::this_thread::get_id()),
     658                 :        242 :       m_dispatcher(this),
     659                 :        242 :       m_memory_monitor(g_memory_monitor_dup_default()),
     660                 :        968 :       m_environment_preparer(cx) {
     661                 :        242 :     JS_SetGCCallback(
     662                 :            :         cx,
     663                 :       1208 :         [](JSContext*, JSGCStatus status, JS::GCReason reason, void* data) {
     664                 :        966 :             static_cast<GjsContextPrivate*>(data)->on_garbage_collection(
     665                 :            :                 status, reason);
     666                 :        966 :         },
     667                 :            :         this);
     668                 :            : 
     669                 :        242 :     const char *env_profiler = g_getenv("GJS_ENABLE_PROFILER");
     670   [ +  +  -  + ]:        242 :     if (env_profiler || m_should_listen_sigusr2)
     671                 :          1 :         m_should_profile = true;
     672                 :            : 
     673         [ +  + ]:        242 :     if (m_should_profile) {
     674                 :          5 :         m_profiler = _gjs_profiler_new(public_context);
     675                 :            : 
     676         [ -  + ]:          5 :         if (!m_profiler) {
     677                 :          0 :             m_should_profile = false;
     678                 :            :         } else {
     679         [ -  + ]:          5 :             if (m_should_listen_sigusr2)
     680                 :          0 :                 _gjs_profiler_setup_signals(m_profiler, public_context);
     681                 :            :         }
     682                 :            :     }
     683                 :            : 
     684                 :        242 :     JSRuntime* rt = JS_GetRuntime(m_cx);
     685                 :        242 :     m_fundamental_table = new JS::WeakCache<FundamentalTable>(rt);
     686                 :        242 :     m_gtype_table = new JS::WeakCache<GTypeTable>(rt);
     687                 :            : 
     688                 :        242 :     m_atoms = new GjsAtoms();
     689                 :            : 
     690         [ -  + ]:        242 :     if (ObjectBox::gtype() == 0)
     691                 :          0 :         g_error("Failed to initialize JSObject GType");
     692                 :            : 
     693                 :            :     JS::RootedObject internal_global(
     694                 :        242 :         m_cx, gjs_create_global_object(cx, GjsGlobalType::INTERNAL));
     695                 :            : 
     696         [ -  + ]:        242 :     if (!internal_global) {
     697                 :          0 :         gjs_log_exception(m_cx);
     698                 :          0 :         g_error("Failed to initialize internal global object");
     699                 :            :     }
     700                 :            : 
     701                 :        242 :     m_internal_global = internal_global;
     702                 :        242 :     Gjs::AutoInternalRealm ar{this};
     703                 :        242 :     JS_AddExtraGCRootsTracer(m_cx, &GjsContextPrivate::trace, this);
     704                 :            : 
     705         [ -  + ]:        242 :     if (!m_atoms->init_atoms(m_cx)) {
     706                 :          0 :         gjs_log_exception(m_cx);
     707                 :          0 :         g_error("Failed to initialize global strings");
     708                 :            :     }
     709                 :            : 
     710         [ -  + ]:        242 :     if (!gjs_define_global_properties(m_cx, internal_global,
     711                 :            :                                       GjsGlobalType::INTERNAL,
     712                 :            :                                       "GJS internal global", "nullptr")) {
     713                 :          0 :         gjs_log_exception(m_cx);
     714                 :          0 :         g_error("Failed to define properties on internal global object");
     715                 :            :     }
     716                 :            : 
     717                 :            :     JS::RootedObject global(
     718                 :        242 :         m_cx,
     719                 :        242 :         gjs_create_global_object(cx, GjsGlobalType::DEFAULT, internal_global));
     720                 :            : 
     721         [ -  + ]:        242 :     if (!global) {
     722                 :          0 :         gjs_log_exception(m_cx);
     723                 :          0 :         g_error("Failed to initialize global object");
     724                 :            :     }
     725                 :            : 
     726                 :        242 :     m_global = global;
     727                 :            : 
     728                 :            :     {
     729                 :        242 :         Gjs::AutoMainRealm ar{this};
     730                 :            : 
     731                 :        242 :         std::vector<std::string> paths;
     732         [ +  + ]:        242 :         if (m_search_path)
     733                 :            :             paths = {m_search_path,
     734                 :        231 :                      m_search_path + g_strv_length(m_search_path)};
     735                 :        242 :         JS::RootedObject importer(m_cx, gjs_create_root_importer(m_cx, paths));
     736         [ -  + ]:        242 :         if (!importer) {
     737                 :          0 :             gjs_log_exception(cx);
     738                 :          0 :             g_error("Failed to create root importer");
     739                 :            :         }
     740                 :            : 
     741                 :        242 :         g_assert(
     742                 :            :             gjs_get_global_slot(global, GjsGlobalSlot::IMPORTS).isUndefined() &&
     743                 :            :             "Someone else already created root importer");
     744                 :            : 
     745                 :        242 :         gjs_set_global_slot(global, GjsGlobalSlot::IMPORTS,
     746                 :        242 :                             JS::ObjectValue(*importer));
     747                 :            : 
     748         [ -  + ]:        242 :         if (!gjs_define_global_properties(m_cx, global, GjsGlobalType::DEFAULT,
     749                 :            :                                           "GJS", "default")) {
     750                 :          0 :             gjs_log_exception(m_cx);
     751                 :          0 :             g_error("Failed to define properties on global object");
     752                 :            :         }
     753                 :        242 :     }
     754                 :            : 
     755                 :        242 :     JS::SetModuleResolveHook(rt, gjs_module_resolve);
     756                 :        242 :     JS::SetModuleDynamicImportHook(rt, gjs_dynamic_module_resolve);
     757                 :        242 :     JS::SetModuleMetadataHook(rt, gjs_populate_module_meta);
     758                 :            : 
     759         [ -  + ]:        242 :     if (!JS_DefineProperty(m_cx, internal_global, "moduleGlobalThis", global,
     760                 :            :                            JSPROP_PERMANENT)) {
     761                 :          0 :         gjs_log_exception(m_cx);
     762                 :          0 :         g_error("Failed to define module global in internal global.");
     763                 :            :     }
     764                 :            : 
     765         [ -  + ]:        242 :     if (!gjs_load_internal_module(cx, "loader")) {
     766                 :          0 :         gjs_log_exception(cx);
     767                 :          0 :         g_error("Failed to load internal module loaders.");
     768                 :            :     }
     769                 :            : 
     770                 :            :     {
     771                 :        242 :         Gjs::AutoMainRealm ar{this};
     772                 :        242 :         load_context_module(
     773                 :            :             cx, "resource:///org/gnome/gjs/modules/esm/_bootstrap/default.js",
     774                 :            :             "ESM bootstrap");
     775                 :        242 :     }
     776                 :            : 
     777                 :        242 :     [[maybe_unused]] bool success = m_main_loop.spin(this);
     778                 :        242 :     g_assert(success && "bootstrap should not call system.exit()");
     779                 :            : 
     780                 :        242 :     g_signal_connect_object(
     781                 :            :         m_memory_monitor, "low-memory-warning",
     782         [ #  # ]:          0 :         G_CALLBACK(+[](GjsContext* js_cx, GMemoryMonitorWarningLevel level) {
     783                 :            :             auto* cx =
     784                 :            :                 static_cast<JSContext*>(gjs_context_get_native_context(js_cx));
     785                 :            :             JS::PrepareForFullGC(cx);
     786                 :            :             JS::GCOptions gc_strength = JS::GCOptions::Normal;
     787                 :            :             if (level > G_MEMORY_MONITOR_WARNING_LEVEL_LOW)
     788                 :            :                 gc_strength = JS::GCOptions::Shrink;
     789                 :            :             JS::NonIncrementalGC(cx, gc_strength, Gjs::GCReason::LOW_MEMORY);
     790                 :            :         }),
     791                 :        242 :         m_public_context, G_CONNECT_SWAPPED);
     792                 :            : 
     793                 :        242 :     start_draining_job_queue();
     794                 :        242 : }
     795                 :            : 
     796                 :         54 : void GjsContextPrivate::set_args(std::vector<std::string>&& args) {
     797                 :         54 :     m_args = args;
     798                 :         54 : }
     799                 :            : 
     800                 :         64 : JSObject* GjsContextPrivate::build_args_array() {
     801                 :         64 :     return gjs_build_string_array(m_cx, m_args);
     802                 :            : }
     803                 :            : 
     804                 :            : static void
     805                 :          0 : gjs_context_get_property (GObject     *object,
     806                 :            :                           guint        prop_id,
     807                 :            :                           GValue      *value,
     808                 :            :                           GParamSpec  *pspec)
     809                 :            : {
     810                 :          0 :     GjsContextPrivate* gjs = GjsContextPrivate::from_object(object);
     811                 :            : 
     812      [ #  #  # ]:          0 :     switch (prop_id) {
     813                 :          0 :     case PROP_PROGRAM_NAME:
     814                 :          0 :         g_value_set_string(value, gjs->program_name());
     815                 :          0 :         break;
     816                 :          0 :     case PROP_PROGRAM_PATH:
     817                 :          0 :         g_value_set_string(value, gjs->program_path());
     818                 :          0 :         break;
     819                 :          0 :     default:
     820                 :          0 :         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     821                 :          0 :         break;
     822                 :            :     }
     823                 :          0 : }
     824                 :            : 
     825                 :            : static void
     826                 :       1452 : gjs_context_set_property (GObject      *object,
     827                 :            :                           guint         prop_id,
     828                 :            :                           const GValue *value,
     829                 :            :                           GParamSpec   *pspec)
     830                 :            : {
     831                 :       1452 :     GjsContextPrivate* gjs = GjsContextPrivate::from_object(object);
     832                 :            : 
     833   [ +  +  +  +  :       1452 :     switch (prop_id) {
                +  +  - ]
     834                 :        242 :     case PROP_SEARCH_PATH:
     835                 :        242 :         gjs->set_search_path(static_cast<char**>(g_value_dup_boxed(value)));
     836                 :        242 :         break;
     837                 :        242 :     case PROP_PROGRAM_NAME:
     838                 :        242 :         gjs->set_program_name(g_value_dup_string(value));
     839                 :        242 :         break;
     840                 :        242 :     case PROP_PROGRAM_PATH:
     841                 :        242 :         gjs->set_program_path(g_value_dup_string(value));
     842                 :        242 :         break;
     843                 :        242 :     case PROP_PROFILER_ENABLED:
     844                 :        242 :         gjs->set_should_profile(g_value_get_boolean(value));
     845                 :        242 :         break;
     846                 :        242 :     case PROP_PROFILER_SIGUSR2:
     847                 :        242 :         gjs->set_should_listen_sigusr2(g_value_get_boolean(value));
     848                 :        242 :         break;
     849                 :        242 :     case PROP_EXEC_AS_MODULE:
     850                 :        242 :         gjs->set_execute_as_module(g_value_get_boolean(value));
     851                 :        242 :         break;
     852                 :          0 :     default:
     853                 :          0 :         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     854                 :          0 :         break;
     855                 :            :     }
     856                 :       1452 : }
     857                 :            : 
     858                 :            : 
     859                 :            : GjsContext*
     860                 :        114 : gjs_context_new(void)
     861                 :            : {
     862                 :        114 :     return (GjsContext*) g_object_new (GJS_TYPE_CONTEXT, NULL);
     863                 :            : }
     864                 :            : 
     865                 :            : GjsContext*
     866                 :         74 : gjs_context_new_with_search_path(char** search_path)
     867                 :            : {
     868                 :         74 :     return (GjsContext*) g_object_new (GJS_TYPE_CONTEXT,
     869                 :            :                          "search-path", search_path,
     870                 :         74 :                          NULL);
     871                 :            : }
     872                 :            : 
     873                 :          0 : gboolean GjsContextPrivate::trigger_gc_if_needed(void* data) {
     874                 :          0 :     auto* gjs = static_cast<GjsContextPrivate*>(data);
     875                 :          0 :     gjs->m_auto_gc_id = 0;
     876                 :            : 
     877         [ #  # ]:          0 :     if (gjs->m_force_gc) {
     878                 :            :         gjs_debug_lifecycle(GJS_DEBUG_CONTEXT, "Big Hammer hit");
     879                 :          0 :         JS_GC(gjs->m_cx, Gjs::GCReason::BIG_HAMMER);
     880                 :            :     } else {
     881                 :          0 :         gjs_gc_if_needed(gjs->m_cx);
     882                 :            :     }
     883                 :          0 :     gjs->m_force_gc = false;
     884                 :            : 
     885                 :          0 :     return G_SOURCE_REMOVE;
     886                 :            : }
     887                 :            : 
     888                 :      14008 : void GjsContextPrivate::schedule_gc_internal(bool force_gc) {
     889                 :      14008 :     m_force_gc |= force_gc;
     890                 :            : 
     891         [ +  + ]:      14008 :     if (m_auto_gc_id > 0)
     892                 :      13869 :         return;
     893                 :            : 
     894                 :            :     if (force_gc)
     895                 :            :         gjs_debug_lifecycle(GJS_DEBUG_CONTEXT, "Big Hammer scheduled");
     896                 :            : 
     897                 :        139 :     m_auto_gc_id = g_timeout_add_seconds_full(G_PRIORITY_LOW, 10,
     898                 :            :                                               trigger_gc_if_needed, this,
     899                 :            :                                               nullptr);
     900                 :            : 
     901         [ -  + ]:        139 :     if (force_gc)
     902                 :          0 :         g_source_set_name_by_id(m_auto_gc_id, "[gjs] Garbage Collection (Big Hammer)");
     903                 :            :     else
     904                 :        139 :         g_source_set_name_by_id(m_auto_gc_id, "[gjs] Garbage Collection");
     905                 :            : }
     906                 :            : 
     907                 :            : /*
     908                 :            :  * GjsContextPrivate::schedule_gc_if_needed:
     909                 :            :  *
     910                 :            :  * Does a minor GC immediately if the JS engine decides one is needed, but also
     911                 :            :  * schedules a full GC in the next idle time.
     912                 :            :  */
     913                 :      12561 : void GjsContextPrivate::schedule_gc_if_needed(void) {
     914                 :            :     // We call JS_MaybeGC immediately, but defer a check for a full GC cycle
     915                 :            :     // to an idle handler.
     916                 :      12561 :     JS_MaybeGC(m_cx);
     917                 :            : 
     918                 :      12561 :     schedule_gc_internal(false);
     919                 :      12561 : }
     920                 :            : 
     921                 :        966 : void GjsContextPrivate::on_garbage_collection(JSGCStatus status, JS::GCReason reason) {
     922                 :        966 :     int64_t now = 0;
     923         [ -  + ]:        966 :     if (m_profiler)
     924                 :          0 :         now = g_get_monotonic_time() * 1000L;
     925                 :            : 
     926      [ +  +  - ]:        966 :     switch (status) {
     927                 :        483 :         case JSGC_BEGIN:
     928                 :        483 :             m_gc_begin_time = now;
     929                 :        483 :             m_gc_reason = gjs_explain_gc_reason(reason);
     930                 :            :             gjs_debug_lifecycle(GJS_DEBUG_CONTEXT,
     931                 :            :                                 "Begin garbage collection because of %s",
     932                 :            :                                 m_gc_reason);
     933                 :            : 
     934                 :            :             // We finalize any pending toggle refs before doing any garbage
     935                 :            :             // collection, so that we can collect the JS wrapper objects, and in
     936                 :            :             // order to minimize the chances of objects having a pending toggle
     937                 :            :             // up queued when they are garbage collected.
     938                 :        483 :             gjs_object_clear_toggles();
     939                 :            : 
     940                 :        483 :             m_async_closures.clear();
     941                 :        483 :             m_async_closures.shrink_to_fit();
     942                 :        483 :             break;
     943                 :        483 :         case JSGC_END:
     944   [ -  +  -  - ]:        483 :             if (m_profiler && m_gc_begin_time != 0) {
     945                 :          0 :                 _gjs_profiler_add_mark(m_profiler, m_gc_begin_time,
     946                 :          0 :                                        now - m_gc_begin_time, "GJS",
     947                 :            :                                        "Garbage collection", m_gc_reason);
     948                 :            :             }
     949                 :        483 :             m_gc_begin_time = 0;
     950                 :        483 :             m_gc_reason = nullptr;
     951                 :            : 
     952                 :        483 :             m_destroy_notifications.shrink_to_fit();
     953                 :            :             gjs_debug_lifecycle(GJS_DEBUG_CONTEXT, "End garbage collection");
     954                 :        483 :             break;
     955                 :          0 :         default:
     956                 :            :             g_assert_not_reached();
     957                 :            :     }
     958                 :        966 : }
     959                 :            : 
     960                 :       2252 : void GjsContextPrivate::set_finalize_status(JSFinalizeStatus status) {
     961                 :            :     // Implementation note for mozjs-24:
     962                 :            :     //
     963                 :            :     // Sweeping happens in two phases, in the first phase all GC things from the
     964                 :            :     // allocation arenas are queued for sweeping, then the actual sweeping
     965                 :            :     // happens. The first phase is marked by JSFINALIZE_GROUP_START, the second
     966                 :            :     // one by JSFINALIZE_GROUP_END, and finally we will see
     967                 :            :     // JSFINALIZE_COLLECTION_END at the end of all GC. (see jsgc.cpp,
     968                 :            :     // BeginSweepPhase/BeginSweepingZoneGroup and SweepPhase, all called from
     969                 :            :     // IncrementalCollectSlice).
     970                 :            :     //
     971                 :            :     // Incremental GC muddies the waters, because BeginSweepPhase is always run
     972                 :            :     // to entirety, but SweepPhase can be run incrementally and mixed with JS
     973                 :            :     // code runs or even native code, when MaybeGC/IncrementalGC return.
     974                 :            :     //
     975                 :            :     // Luckily for us, objects are treated specially, and are not really queued
     976                 :            :     // for deferred incremental finalization (unless they are marked for
     977                 :            :     // background sweeping). Instead, they are finalized immediately during
     978                 :            :     // phase 1, so the following guarantees are true (and we rely on them):
     979                 :            :     // - phase 1 of GC will begin and end in the same JSAPI call (i.e., our
     980                 :            :     //   callback will be called with GROUP_START and the triggering JSAPI call
     981                 :            :     //   will not return until we see a GROUP_END)
     982                 :            :     // - object finalization will begin and end in the same JSAPI call
     983                 :            :     // - therefore, if there is a finalizer frame somewhere in the stack,
     984                 :            :     //   GjsContextPrivate::sweeping() will return true.
     985                 :            :     //
     986                 :            :     // Comments in mozjs-24 imply that this behavior might change in the future,
     987                 :            :     // but it hasn't changed in mozilla-central as of 2014-02-23. In addition to
     988                 :            :     // that, the mozilla-central version has a huge comment in a different
     989                 :            :     // portion of the file, explaining why finalization of objects can't be
     990                 :            :     // mixed with JS code, so we can probably rely on this behavior.
     991                 :            : 
     992                 :       2252 :     int64_t now = 0;
     993                 :            : 
     994         [ -  + ]:       2252 :     if (m_profiler)
     995                 :          0 :         now = g_get_monotonic_time() * 1000L;
     996                 :            : 
     997   [ +  +  +  +  :       2252 :     switch (status) {
                      - ]
     998                 :        563 :         case JSFINALIZE_GROUP_PREPARE:
     999                 :        563 :             m_in_gc_sweep = true;
    1000                 :        563 :             m_sweep_begin_time = now;
    1001                 :        563 :             break;
    1002                 :        563 :         case JSFINALIZE_GROUP_START:
    1003                 :        563 :             m_group_sweep_begin_time = now;
    1004                 :        563 :             break;
    1005                 :        563 :         case JSFINALIZE_GROUP_END:
    1006   [ -  +  -  - ]:        563 :             if (m_profiler && m_group_sweep_begin_time != 0) {
    1007                 :          0 :                 _gjs_profiler_add_mark(m_profiler, m_group_sweep_begin_time,
    1008                 :          0 :                                        now - m_group_sweep_begin_time, "GJS",
    1009                 :            :                                        "Group sweep", nullptr);
    1010                 :            :             }
    1011                 :        563 :             m_group_sweep_begin_time = 0;
    1012                 :        563 :             break;
    1013                 :        563 :         case JSFINALIZE_COLLECTION_END:
    1014                 :        563 :             m_in_gc_sweep = false;
    1015   [ -  +  -  - ]:        563 :             if (m_profiler && m_sweep_begin_time != 0) {
    1016                 :          0 :                 _gjs_profiler_add_mark(m_profiler, m_sweep_begin_time,
    1017                 :          0 :                                        now - m_sweep_begin_time, "GJS", "Sweep",
    1018                 :            :                                        nullptr);
    1019                 :            :             }
    1020                 :        563 :             m_sweep_begin_time = 0;
    1021                 :        563 :             break;
    1022                 :          0 :         default:
    1023                 :            :             g_assert_not_reached();
    1024                 :            :     }
    1025                 :       2252 : }
    1026                 :            : 
    1027                 :         30 : void GjsContextPrivate::exit(uint8_t exit_code) {
    1028                 :         30 :     g_assert(!m_should_exit);
    1029                 :         30 :     m_should_exit = true;
    1030                 :         30 :     m_exit_code = exit_code;
    1031                 :         30 : }
    1032                 :            : 
    1033                 :       1645 : bool GjsContextPrivate::should_exit(uint8_t* exit_code_p) const {
    1034         [ +  + ]:       1645 :     if (exit_code_p != NULL)
    1035                 :        364 :         *exit_code_p = m_exit_code;
    1036                 :       1645 :     return m_should_exit;
    1037                 :            : }
    1038                 :            : 
    1039                 :          2 : void GjsContextPrivate::exit_immediately(uint8_t exit_code) {
    1040                 :          2 :     warn_about_unhandled_promise_rejections();
    1041                 :            : 
    1042                 :          2 :     ::exit(exit_code);
    1043                 :            : }
    1044                 :            : 
    1045                 :       2957 : void GjsContextPrivate::start_draining_job_queue(void) { m_dispatcher.start(); }
    1046                 :            : 
    1047                 :       2955 : void GjsContextPrivate::stop_draining_job_queue(void) {
    1048                 :       2955 :     m_draining_job_queue = false;
    1049                 :       2955 :     m_dispatcher.stop();
    1050                 :       2955 : }
    1051                 :            : 
    1052                 :        985 : JSObject* GjsContextPrivate::getIncumbentGlobal(JSContext* cx) {
    1053                 :            :     // This is equivalent to SpiderMonkey's behavior.
    1054                 :        985 :     return JS::CurrentGlobalOrNull(cx);
    1055                 :            : }
    1056                 :            : 
    1057                 :            : // See engine.cpp and JS::SetJobQueue().
    1058                 :        979 : bool GjsContextPrivate::enqueuePromiseJob(JSContext* cx [[maybe_unused]],
    1059                 :            :                                           JS::HandleObject promise,
    1060                 :            :                                           JS::HandleObject job,
    1061                 :            :                                           JS::HandleObject allocation_site,
    1062                 :            :                                           JS::HandleObject incumbent_global
    1063                 :            :                                           [[maybe_unused]]) {
    1064                 :        979 :     g_assert(cx == m_cx);
    1065                 :        979 :     g_assert(from_cx(cx) == this);
    1066                 :            : 
    1067                 :       2937 :     gjs_debug(GJS_DEBUG_MAINLOOP,
    1068                 :            :               "Enqueue job %s, promise=%s, allocation site=%s",
    1069                 :       2937 :               gjs_debug_object(job).c_str(), gjs_debug_object(promise).c_str(),
    1070                 :       1958 :               gjs_debug_object(allocation_site).c_str());
    1071                 :            : 
    1072         [ -  + ]:        979 :     if (!m_job_queue.append(job)) {
    1073                 :          0 :         JS_ReportOutOfMemory(m_cx);
    1074                 :          0 :         return false;
    1075                 :            :     }
    1076                 :            : 
    1077                 :        979 :     JS::JobQueueMayNotBeEmpty(m_cx);
    1078                 :        979 :     m_dispatcher.start();
    1079                 :        979 :     return true;
    1080                 :            : }
    1081                 :            : 
    1082                 :            : // Override of JobQueue::runJobs(). Called by js::RunJobs(), and when execution
    1083                 :            : // of the job queue was interrupted by the debugger and is resuming.
    1084                 :       8442 : void GjsContextPrivate::runJobs(JSContext* cx) {
    1085                 :       8442 :     g_assert(cx == m_cx);
    1086                 :       8442 :     g_assert(from_cx(cx) == this);
    1087         [ +  + ]:       8442 :     if (!run_jobs_fallible())
    1088                 :          3 :         gjs_log_exception(cx);
    1089                 :       8442 : }
    1090                 :            : 
    1091                 :            : /*
    1092                 :            :  * GjsContext::run_jobs_fallible:
    1093                 :            :  *
    1094                 :            :  * Drains the queue of promise callbacks that the JS engine has reported
    1095                 :            :  * finished, calling each one and logging any exceptions that it throws.
    1096                 :            :  *
    1097                 :            :  * Adapted from js::RunJobs() in SpiderMonkey's default job queue
    1098                 :            :  * implementation.
    1099                 :            :  *
    1100                 :            :  * Returns: false if one of the jobs threw an uncatchable exception;
    1101                 :            :  * otherwise true.
    1102                 :            :  */
    1103                 :       8467 : bool GjsContextPrivate::run_jobs_fallible() {
    1104                 :       8467 :     bool retval = true;
    1105                 :            : 
    1106   [ +  -  +  + ]:       8467 :     if (m_draining_job_queue || m_should_exit)
    1107                 :         28 :         return true;
    1108                 :            : 
    1109                 :       8439 :     m_draining_job_queue = true;  // Ignore reentrant calls
    1110                 :            : 
    1111                 :       8439 :     JS::RootedObject job(m_cx);
    1112                 :       8439 :     JS::HandleValueArray args(JS::HandleValueArray::empty());
    1113                 :       8439 :     JS::RootedValue rval(m_cx);
    1114                 :            : 
    1115         [ +  + ]:       8439 :     if (m_job_queue.length() == 0) {
    1116                 :            :         // Check FinalizationRegistry cleanup tasks at least once if there are
    1117                 :            :         // no microtasks queued. This may enqueue more microtasks, which will be
    1118                 :            :         // appended to m_job_queue.
    1119         [ -  + ]:       7944 :         if (!run_finalization_registry_cleanup())
    1120                 :          0 :             retval = false;
    1121                 :            :     }
    1122                 :            : 
    1123                 :            :     /* Execute jobs in a loop until we've reached the end of the queue.
    1124                 :            :      * Since executing a job can trigger enqueueing of additional jobs,
    1125                 :            :      * it's crucial to recheck the queue length during each iteration. */
    1126         [ +  + ]:       9415 :     for (size_t ix = 0; ix < m_job_queue.length(); ix++) {
    1127                 :            :         /* A previous job might have set this flag. e.g., System.exit(). */
    1128   [ +  +  -  +  :        977 :         if (m_should_exit || !m_dispatcher.is_running()) {
                   +  + ]
    1129                 :          1 :             gjs_debug(GJS_DEBUG_MAINLOOP, "Stopping jobs because of %s",
    1130         [ +  - ]:          1 :                       m_should_exit ? "exit" : "main loop cancel");
    1131                 :          1 :             break;
    1132                 :            :         }
    1133                 :            : 
    1134                 :        976 :         job = m_job_queue[ix];
    1135                 :            : 
    1136                 :            :         /* It's possible that job draining was interrupted prematurely,
    1137                 :            :          * leaving the queue partly processed. In that case, slots for
    1138                 :            :          * already-executed entries will contain nullptrs, which we should
    1139                 :            :          * just skip. */
    1140         [ -  + ]:        976 :         if (!job)
    1141                 :          0 :             continue;
    1142                 :            : 
    1143                 :        976 :         m_job_queue[ix] = nullptr;
    1144                 :            :         {
    1145                 :        976 :             JSAutoRealm ar(m_cx, job);
    1146                 :        976 :             gjs_debug(GJS_DEBUG_MAINLOOP, "handling job %zu, %s", ix,
    1147                 :       1952 :                       gjs_debug_object(job).c_str());
    1148         [ +  + ]:        976 :             if (!JS::Call(m_cx, JS::UndefinedHandleValue, job, args, &rval)) {
    1149                 :            :                 /* Uncatchable exception - return false so that
    1150                 :            :                  * System.exit() works in the interactive shell and when
    1151                 :            :                  * exiting the interpreter. */
    1152         [ +  - ]:          3 :                 if (!JS_IsExceptionPending(m_cx)) {
    1153                 :            :                     /* System.exit() is an uncatchable exception, but does not
    1154                 :            :                      * indicate a bug. Log everything else. */
    1155         [ -  + ]:          3 :                     if (!should_exit(nullptr))
    1156                 :          0 :                         g_critical("Promise callback terminated with uncatchable exception");
    1157                 :          3 :                     retval = false;
    1158                 :          3 :                     continue;
    1159                 :            :                 }
    1160                 :            : 
    1161                 :            :                 /* There's nowhere for the exception to go at this point */
    1162                 :          0 :                 gjs_log_exception_uncaught(m_cx);
    1163                 :            :             }
    1164         [ +  + ]:        976 :         }
    1165                 :        973 :         gjs_debug(GJS_DEBUG_MAINLOOP, "Completed job %zu", ix);
    1166                 :            : 
    1167                 :            :         // Run FinalizationRegistry cleanup tasks after each job. Cleanup tasks
    1168                 :            :         // may enqueue more microtasks, which will be appended to m_job_queue.
    1169         [ -  + ]:        973 :         if (!run_finalization_registry_cleanup())
    1170                 :          0 :             retval = false;
    1171                 :            :     }
    1172                 :            : 
    1173                 :       8439 :     m_draining_job_queue = false;
    1174                 :       8439 :     m_job_queue.clear();
    1175                 :       8439 :     warn_about_unhandled_promise_rejections();
    1176                 :       8439 :     JS::JobQueueIsEmpty(m_cx);
    1177                 :       8439 :     return retval;
    1178                 :       8439 : }
    1179                 :            : 
    1180                 :       8917 : bool GjsContextPrivate::run_finalization_registry_cleanup() {
    1181                 :       8917 :     bool retval = true;
    1182                 :            : 
    1183                 :       8917 :     JS::Rooted<FunctionVector> tasks{m_cx};
    1184                 :       8917 :     std::swap(tasks.get(), m_cleanup_tasks);
    1185                 :       8917 :     g_assert(m_cleanup_tasks.empty());
    1186                 :            : 
    1187                 :       8917 :     JS::RootedFunction task{m_cx};
    1188                 :       8917 :     JS::RootedValue unused_rval{m_cx};
    1189         [ +  + ]:       8922 :     for (JSFunction* func : tasks) {
    1190                 :          5 :         gjs_debug(GJS_DEBUG_MAINLOOP,
    1191                 :            :                   "Running FinalizationRegistry cleanup callback");
    1192                 :            : 
    1193                 :          5 :         task.set(func);
    1194                 :          5 :         JS::ExposeObjectToActiveJS(JS_GetFunctionObject(func));
    1195                 :            : 
    1196                 :          5 :         JSAutoRealm ar{m_cx, JS_GetFunctionObject(func)};
    1197         [ -  + ]:          5 :         if (!JS_CallFunction(m_cx, nullptr, task, JS::HandleValueArray::empty(),
    1198                 :            :                              &unused_rval)) {
    1199                 :            :             // Same logic as above
    1200         [ #  # ]:          0 :             if (!JS_IsExceptionPending(m_cx)) {
    1201         [ #  # ]:          0 :                 if (!should_exit(nullptr))
    1202                 :          0 :                     g_critical(
    1203                 :            :                         "FinalizationRegistry callback terminated with "
    1204                 :            :                         "uncatchable exception");
    1205                 :          0 :                 retval = false;
    1206                 :          0 :                 continue;
    1207                 :            :             }
    1208                 :          0 :             gjs_log_exception_uncaught(m_cx);
    1209                 :            :         }
    1210                 :            : 
    1211                 :          5 :         gjs_debug(GJS_DEBUG_MAINLOOP,
    1212                 :            :                   "Completed FinalizationRegistry cleanup callback");
    1213         [ +  - ]:          5 :     }
    1214                 :            : 
    1215                 :      17834 :     return retval;
    1216                 :       8917 : }
    1217                 :            : 
    1218                 :            : class GjsContextPrivate::SavedQueue : public JS::JobQueue::SavedJobQueue {
    1219                 :            :  private:
    1220                 :            :     GjsContextPrivate* m_gjs;
    1221                 :            :     JS::PersistentRooted<JobQueueStorage> m_queue;
    1222                 :            :     bool m_was_draining : 1;
    1223                 :            : 
    1224                 :            :  public:
    1225                 :       2715 :     explicit SavedQueue(GjsContextPrivate* gjs)
    1226                 :       5430 :         : m_gjs(gjs),
    1227                 :       2715 :           m_queue(gjs->m_cx, std::move(gjs->m_job_queue)),
    1228                 :       2715 :           m_was_draining(gjs->m_draining_job_queue) {
    1229                 :       2715 :         gjs_debug(GJS_DEBUG_CONTEXT, "Pausing job queue");
    1230                 :       2715 :         gjs->stop_draining_job_queue();
    1231                 :       2715 :     }
    1232                 :            : 
    1233                 :       2715 :     ~SavedQueue(void) {
    1234                 :       2715 :         gjs_debug(GJS_DEBUG_CONTEXT, "Unpausing job queue");
    1235                 :       2715 :         m_gjs->m_job_queue = std::move(m_queue.get());
    1236                 :       2715 :         m_gjs->m_draining_job_queue = m_was_draining;
    1237                 :       2715 :         m_gjs->start_draining_job_queue();
    1238                 :       2715 :     }
    1239                 :            : };
    1240                 :            : 
    1241                 :       2715 : js::UniquePtr<JS::JobQueue::SavedJobQueue> GjsContextPrivate::saveJobQueue(
    1242                 :            :     JSContext* cx) {
    1243                 :       2715 :     g_assert(cx == m_cx);
    1244                 :       2715 :     g_assert(from_cx(cx) == this);
    1245                 :            : 
    1246                 :       2715 :     auto saved_queue = js::MakeUnique<SavedQueue>(this);
    1247         [ -  + ]:       2715 :     if (!saved_queue) {
    1248                 :          0 :         JS_ReportOutOfMemory(cx);
    1249                 :          0 :         return nullptr;
    1250                 :            :     }
    1251                 :            : 
    1252                 :       2715 :     g_assert(m_job_queue.empty());
    1253                 :       2715 :     return saved_queue;
    1254                 :       2715 : }
    1255                 :            : 
    1256                 :         14 : void GjsContextPrivate::register_unhandled_promise_rejection(
    1257                 :            :     uint64_t id, JS::UniqueChars&& stack) {
    1258                 :         14 :     m_unhandled_rejection_stacks[id] = std::move(stack);
    1259                 :         14 : }
    1260                 :            : 
    1261                 :         13 : void GjsContextPrivate::unregister_unhandled_promise_rejection(uint64_t id) {
    1262                 :         13 :     size_t erased = m_unhandled_rejection_stacks.erase(id);
    1263         [ -  + ]:         13 :     if (erased != 1) {
    1264                 :          0 :         g_critical("Promise %" G_GUINT64_FORMAT
    1265                 :            :                    " Handler attached to rejected promise that wasn't "
    1266                 :            :                    "previously marked as unhandled or that we wrongly reported "
    1267                 :            :                    "as unhandled",
    1268                 :            :                    id);
    1269                 :            :     }
    1270                 :         13 : }
    1271                 :            : 
    1272                 :          5 : bool GjsContextPrivate::queue_finalization_registry_cleanup(
    1273                 :            :     JSFunction* cleanup_task) {
    1274                 :          5 :     return m_cleanup_tasks.append(cleanup_task);
    1275                 :            : }
    1276                 :            : 
    1277                 :        111 : void GjsContextPrivate::async_closure_enqueue_for_gc(Gjs::Closure* trampoline) {
    1278                 :            :     //  Because we can't free the mmap'd data for a callback
    1279                 :            :     //  while it's in use, this list keeps track of ones that
    1280                 :            :     //  will be freed the next time gc happens
    1281                 :        111 :     g_assert(!trampoline->context() || trampoline->context() == m_cx);
    1282                 :        111 :     m_async_closures.emplace_back(trampoline);
    1283                 :        111 : }
    1284                 :            : 
    1285                 :            : /**
    1286                 :            :  * gjs_context_maybe_gc:
    1287                 :            :  * @context: a #GjsContext
    1288                 :            :  *
    1289                 :            :  * Similar to the Spidermonkey JS_MaybeGC() call which
    1290                 :            :  * heuristically looks at JS runtime memory usage and
    1291                 :            :  * may initiate a garbage collection.
    1292                 :            :  *
    1293                 :            :  * This function always unconditionally invokes JS_MaybeGC(), but
    1294                 :            :  * additionally looks at memory usage from the system malloc()
    1295                 :            :  * when available, and if the delta has grown since the last run
    1296                 :            :  * significantly, also initiates a full JavaScript garbage
    1297                 :            :  * collection.  The idea is that since GJS is a bridge between
    1298                 :            :  * JavaScript and system libraries, and JS objects act as proxies
    1299                 :            :  * for these system memory objects, GJS consumers need a way to
    1300                 :            :  * hint to the runtime that it may be a good idea to try a
    1301                 :            :  * collection.
    1302                 :            :  *
    1303                 :            :  * A good time to call this function is when your application
    1304                 :            :  * transitions to an idle state.
    1305                 :            :  */
    1306                 :            : void
    1307                 :          0 : gjs_context_maybe_gc (GjsContext  *context)
    1308                 :            : {
    1309                 :          0 :     GjsContextPrivate* gjs = GjsContextPrivate::from_object(context);
    1310                 :          0 :     gjs_maybe_gc(gjs->context());
    1311                 :          0 : }
    1312                 :            : 
    1313                 :            : /**
    1314                 :            :  * gjs_context_gc:
    1315                 :            :  * @context: a #GjsContext
    1316                 :            :  *
    1317                 :            :  * Initiate a full GC; may or may not block until complete.  This
    1318                 :            :  * function just calls Spidermonkey JS_GC().
    1319                 :            :  */
    1320                 :            : void
    1321                 :          0 : gjs_context_gc (GjsContext  *context)
    1322                 :            : {
    1323                 :          0 :     GjsContextPrivate* gjs = GjsContextPrivate::from_object(context);
    1324                 :          0 :     JS_GC(gjs->context(), Gjs::GCReason::GJS_API_CALL);
    1325                 :          0 : }
    1326                 :            : 
    1327                 :            : /**
    1328                 :            :  * gjs_context_get_all:
    1329                 :            :  *
    1330                 :            :  * Returns a newly-allocated list containing all known instances of #GjsContext.
    1331                 :            :  * This is useful for operating on the contexts from a process-global situation
    1332                 :            :  * such as a debugger.
    1333                 :            :  *
    1334                 :            :  * Return value: (element-type GjsContext) (transfer full): Known #GjsContext instances
    1335                 :            :  */
    1336                 :            : GList*
    1337                 :         44 : gjs_context_get_all(void)
    1338                 :            : {
    1339                 :            :   GList *result;
    1340                 :            :   GList *iter;
    1341                 :         44 :   g_mutex_lock (&contexts_lock);
    1342                 :         44 :   result = g_list_copy(all_contexts);
    1343         [ +  + ]:         88 :   for (iter = result; iter; iter = iter->next)
    1344                 :         44 :     g_object_ref((GObject*)iter->data);
    1345                 :         44 :   g_mutex_unlock (&contexts_lock);
    1346                 :         44 :   return result;
    1347                 :            : }
    1348                 :            : 
    1349                 :            : /**
    1350                 :            :  * gjs_context_get_native_context:
    1351                 :            :  *
    1352                 :            :  * Returns a pointer to the underlying native context.  For SpiderMonkey, this
    1353                 :            :  * is a JSContext *
    1354                 :            :  */
    1355                 :            : void*
    1356                 :       1537 : gjs_context_get_native_context (GjsContext *js_context)
    1357                 :            : {
    1358                 :       1537 :     g_return_val_if_fail(GJS_IS_CONTEXT(js_context), NULL);
    1359                 :       1537 :     GjsContextPrivate* gjs = GjsContextPrivate::from_object(js_context);
    1360                 :       1537 :     return gjs->context();
    1361                 :            : }
    1362                 :            : 
    1363                 :            : bool
    1364                 :        248 : gjs_context_eval(GjsContext   *js_context,
    1365                 :            :                  const char   *script,
    1366                 :            :                  gssize        script_len,
    1367                 :            :                  const char   *filename,
    1368                 :            :                  int          *exit_status_p,
    1369                 :            :                  GError      **error)
    1370                 :            : {
    1371                 :        248 :     g_return_val_if_fail(GJS_IS_CONTEXT(js_context), false);
    1372                 :            : 
    1373         [ +  + ]:        248 :     size_t real_len = script_len < 0 ? strlen(script) : script_len;
    1374                 :            : 
    1375                 :        248 :     GjsAutoUnref<GjsContext> js_context_ref(js_context, GjsAutoTakeOwnership());
    1376                 :            : 
    1377                 :        248 :     GjsContextPrivate* gjs = GjsContextPrivate::from_object(js_context);
    1378                 :        248 :     return gjs->eval(script, real_len, filename, exit_status_p, error);
    1379                 :        247 : }
    1380                 :            : 
    1381                 :        120 : bool gjs_context_eval_module(GjsContext* js_context, const char* identifier,
    1382                 :            :                              uint8_t* exit_code, GError** error) {
    1383                 :        120 :     g_return_val_if_fail(GJS_IS_CONTEXT(js_context), false);
    1384                 :            : 
    1385                 :        120 :     GjsAutoUnref<GjsContext> js_context_ref(js_context, GjsAutoTakeOwnership());
    1386                 :            : 
    1387                 :        120 :     GjsContextPrivate* gjs = GjsContextPrivate::from_object(js_context);
    1388                 :        120 :     return gjs->eval_module(identifier, exit_code, error);
    1389                 :        119 : }
    1390                 :            : 
    1391                 :        122 : bool gjs_context_register_module(GjsContext* js_context, const char* identifier,
    1392                 :            :                                  const char* uri, GError** error) {
    1393                 :        122 :     g_return_val_if_fail(GJS_IS_CONTEXT(js_context), false);
    1394                 :            : 
    1395                 :        122 :     GjsContextPrivate* gjs = GjsContextPrivate::from_object(js_context);
    1396                 :            : 
    1397                 :        122 :     return gjs->register_module(identifier, uri, error);
    1398                 :            : }
    1399                 :            : 
    1400                 :        368 : bool GjsContextPrivate::auto_profile_enter() {
    1401                 :        368 :     bool auto_profile = m_should_profile;
    1402   [ +  +  +  +  :        476 :     if (auto_profile &&
                   +  + ]
    1403         [ -  + ]:        108 :         (_gjs_profiler_is_running(m_profiler) || m_should_listen_sigusr2))
    1404                 :        100 :         auto_profile = false;
    1405                 :            : 
    1406                 :        368 :     Gjs::AutoMainRealm ar{this};
    1407                 :            : 
    1408         [ +  + ]:        368 :     if (auto_profile)
    1409                 :          4 :         gjs_profiler_start(m_profiler);
    1410                 :            : 
    1411                 :        736 :     return auto_profile;
    1412                 :        368 : }
    1413                 :            : 
    1414                 :        362 : void GjsContextPrivate::auto_profile_exit(bool auto_profile) {
    1415         [ +  + ]:        362 :     if (auto_profile)
    1416                 :          4 :         gjs_profiler_stop(m_profiler);
    1417                 :        362 : }
    1418                 :            : 
    1419                 :        362 : bool GjsContextPrivate::handle_exit_code(bool no_sync_error_pending,
    1420                 :            :                                          const char* source_type,
    1421                 :            :                                          const char* identifier,
    1422                 :            :                                          uint8_t* exit_code, GError** error) {
    1423                 :            :     uint8_t code;
    1424         [ +  + ]:        362 :     if (should_exit(&code)) {
    1425                 :            :         /* exit_status_p is public API so can't be changed, but should be
    1426                 :            :          * uint8_t, not int */
    1427                 :         28 :         g_set_error(error, GJS_ERROR, GJS_ERROR_SYSTEM_EXIT,
    1428                 :            :                     "Exit with code %d", code);
    1429                 :            : 
    1430                 :         28 :         *exit_code = code;
    1431                 :         28 :         return false;  // Don't log anything
    1432                 :            :     }
    1433                 :            : 
    1434                 :            :     // Once the main loop exits an exception could
    1435                 :            :     // be pending even if the script returned
    1436                 :            :     // true synchronously
    1437         [ +  + ]:        334 :     if (JS_IsExceptionPending(m_cx)) {
    1438                 :          2 :         g_set_error(error, GJS_ERROR, GJS_ERROR_FAILED,
    1439                 :            :                     "%s %s threw an exception", source_type, identifier);
    1440                 :          2 :         gjs_log_exception_uncaught(m_cx);
    1441                 :            : 
    1442                 :          2 :         *exit_code = 1;
    1443                 :          2 :         return false;
    1444                 :            :     }
    1445                 :            : 
    1446         [ +  + ]:        332 :     if (m_unhandled_exception) {
    1447                 :          1 :         g_set_error(error, GJS_ERROR, GJS_ERROR_FAILED,
    1448                 :            :                     "%s %s threw an exception", source_type, identifier);
    1449                 :          1 :         *exit_code = 1;
    1450                 :          1 :         return false;
    1451                 :            :     }
    1452                 :            : 
    1453                 :            :     // Assume success if no error was thrown and should exit isn't
    1454                 :            :     // set
    1455         [ +  - ]:        331 :     if (no_sync_error_pending) {
    1456                 :        331 :         *exit_code = 0;
    1457                 :        331 :         return true;
    1458                 :            :     }
    1459                 :            : 
    1460                 :          0 :     g_critical("%s %s terminated with an uncatchable exception", source_type,
    1461                 :            :                identifier);
    1462                 :          0 :     g_set_error(error, GJS_ERROR, GJS_ERROR_FAILED,
    1463                 :            :                 "%s %s terminated with an uncatchable exception", source_type,
    1464                 :            :                 identifier);
    1465                 :            : 
    1466                 :          0 :     gjs_log_exception_uncaught(m_cx);
    1467                 :            :     /* No exit code from script, but we don't want to exit(0) */
    1468                 :          0 :     *exit_code = 1;
    1469                 :          0 :     return false;
    1470                 :            : }
    1471                 :            : 
    1472                 :         50 : bool GjsContextPrivate::set_main_loop_hook(JSObject* callable) {
    1473                 :         50 :     g_assert(JS::IsCallable(callable) && "main loop hook must be a callable object");
    1474                 :            : 
    1475         [ -  + ]:         50 :     if (!callable) {
    1476                 :          0 :         m_main_loop_hook = nullptr;
    1477                 :          0 :         return true;
    1478                 :            :     }
    1479                 :            : 
    1480         [ -  + ]:         50 :     if (m_main_loop_hook)
    1481                 :          0 :         return false;
    1482                 :            : 
    1483                 :         50 :     m_main_loop_hook = callable;
    1484                 :         50 :     return true;
    1485                 :            : }
    1486                 :            : 
    1487                 :         50 : bool GjsContextPrivate::run_main_loop_hook() {
    1488                 :         50 :     JS::RootedObject hook(m_cx, m_main_loop_hook.get());
    1489                 :         50 :     m_main_loop_hook = nullptr;
    1490                 :         50 :     gjs_debug(GJS_DEBUG_MAINLOOP, "Running and clearing main loop hook");
    1491                 :         50 :     JS::RootedValue ignored_rval(m_cx);
    1492                 :        100 :     return JS::Call(m_cx, JS::NullHandleValue, hook,
    1493                 :        100 :                     JS::HandleValueArray::empty(), &ignored_rval);
    1494                 :         50 : }
    1495                 :            : 
    1496                 :        248 : bool GjsContextPrivate::eval(const char* script, size_t script_len,
    1497                 :            :                              const char* filename, int* exit_status_p,
    1498                 :            :                              GError** error) {
    1499                 :        248 :     AutoResetExit reset(this);
    1500                 :            : 
    1501                 :        248 :     bool auto_profile = auto_profile_enter();
    1502                 :            : 
    1503                 :        248 :     Gjs::AutoMainRealm ar{this};
    1504                 :            : 
    1505                 :        248 :     JS::RootedValue retval(m_cx);
    1506                 :        248 :     bool ok = eval_with_scope(nullptr, script, script_len, filename, &retval);
    1507                 :            : 
    1508                 :            :     // If there are no errors and the mainloop hook is set, call it.
    1509   [ +  +  -  +  :        247 :     if (ok && m_main_loop_hook)
                   -  + ]
    1510                 :          0 :         ok = run_main_loop_hook();
    1511                 :            : 
    1512                 :        247 :     bool exiting = false;
    1513                 :            : 
    1514                 :            :     // Spin the internal loop until the main loop hook is set or no holds
    1515                 :            :     // remain.
    1516                 :            :     // If the main loop returns false we cannot guarantee the state of our
    1517                 :            :     // promise queue (a module promise could be pending) so instead of draining
    1518                 :            :     // draining the queue we instead just exit.
    1519   [ +  +  +  +  :        247 :     if (ok && !m_main_loop.spin(this)) {
                   +  + ]
    1520                 :          2 :         exiting = true;
    1521                 :            :     }
    1522                 :            : 
    1523                 :            :     // If the hook has been set again, enter a loop until an error is
    1524                 :            :     // encountered or the main loop is quit.
    1525   [ +  +  +  +  :        247 :     while (ok && !exiting && m_main_loop_hook) {
             -  +  -  + ]
    1526                 :          0 :         ok = run_main_loop_hook();
    1527                 :            : 
    1528                 :            :         // Additional jobs could have been enqueued from the
    1529                 :            :         // main loop hook
    1530   [ #  #  #  #  :          0 :         if (ok && !m_main_loop.spin(this)) {
                   #  # ]
    1531                 :          0 :             exiting = true;
    1532                 :            :         }
    1533                 :            :     }
    1534                 :            : 
    1535                 :            :     // The promise job queue should be drained even on error, to finish
    1536                 :            :     // outstanding async tasks before the context is torn down. Drain after
    1537                 :            :     // uncaught exceptions have been reported since draining runs callbacks.
    1538                 :            :     // We do not drain if we are exiting.
    1539   [ +  +  +  - ]:        247 :     if (!ok && !exiting) {
    1540                 :         25 :         JS::AutoSaveExceptionState saved_exc(m_cx);
    1541   [ +  -  -  + ]:         25 :         ok = run_jobs_fallible() && ok;
    1542                 :         25 :     }
    1543                 :            : 
    1544                 :        247 :     auto_profile_exit(auto_profile);
    1545                 :            : 
    1546                 :            :     uint8_t out_code;
    1547                 :        247 :     ok = handle_exit_code(ok, "Script", filename, &out_code, error);
    1548                 :            : 
    1549         [ +  + ]:        247 :     if (exit_status_p) {
    1550   [ +  +  +  +  :        222 :         if (ok && retval.isInt32()) {
                   +  + ]
    1551                 :          5 :             int code = retval.toInt32();
    1552                 :          5 :             gjs_debug(GJS_DEBUG_CONTEXT,
    1553                 :            :                       "Script returned integer code %d", code);
    1554                 :          5 :             *exit_status_p = code;
    1555                 :            :         } else {
    1556                 :        217 :             *exit_status_p = out_code;
    1557                 :            :         }
    1558                 :            :     }
    1559                 :            : 
    1560                 :        494 :     return ok;
    1561                 :        247 : }
    1562                 :            : 
    1563                 :        120 : bool GjsContextPrivate::eval_module(const char* identifier,
    1564                 :            :                                     uint8_t* exit_status_p, GError** error) {
    1565                 :        120 :     AutoResetExit reset(this);
    1566                 :            : 
    1567                 :        120 :     bool auto_profile = auto_profile_enter();
    1568                 :            : 
    1569                 :        120 :     Gjs::AutoMainRealm ar{this};
    1570                 :            : 
    1571                 :        120 :     JS::RootedObject registry(m_cx, gjs_get_module_registry(m_global));
    1572                 :        120 :     JS::RootedId key(m_cx, gjs_intern_string_to_id(m_cx, identifier));
    1573                 :        120 :     JS::RootedObject obj(m_cx);
    1574   [ +  -  +  +  :        120 :     if (!gjs_global_registry_get(m_cx, registry, key, &obj) || !obj) {
                   +  + ]
    1575                 :          2 :         g_set_error(error, GJS_ERROR, GJS_ERROR_FAILED,
    1576                 :            :                     "Cannot load module with identifier: '%s'", identifier);
    1577                 :            : 
    1578         [ +  + ]:          2 :         if (exit_status_p)
    1579                 :          1 :             *exit_status_p = 1;
    1580                 :          2 :         return false;
    1581                 :            :     }
    1582                 :            : 
    1583         [ +  + ]:        118 :     if (!JS::ModuleLink(m_cx, obj)) {
    1584                 :          2 :         gjs_log_exception(m_cx);
    1585                 :          2 :         g_set_error(error, GJS_ERROR, GJS_ERROR_FAILED,
    1586                 :            :                     "Failed to resolve imports for module: '%s'", identifier);
    1587                 :            : 
    1588         [ +  + ]:          2 :         if (exit_status_p)
    1589                 :          1 :             *exit_status_p = 1;
    1590                 :          2 :         return false;
    1591                 :            :     }
    1592                 :            : 
    1593                 :        116 :     JS::RootedValue evaluation_promise(m_cx);
    1594                 :        116 :     bool ok = JS::ModuleEvaluate(m_cx, obj, &evaluation_promise);
    1595                 :            : 
    1596         [ +  - ]:        115 :     if (ok) {
    1597                 :        115 :         GjsContextPrivate::from_cx(m_cx)->main_loop_hold();
    1598                 :            : 
    1599                 :        230 :         ok = add_promise_reactions(
    1600                 :            :             m_cx, evaluation_promise, on_context_module_resolved,
    1601                 :            :             on_context_module_rejected_log_exception, identifier);
    1602                 :            :     }
    1603                 :            : 
    1604                 :        115 :     bool exiting = false;
    1605                 :            : 
    1606                 :            :     do {
    1607                 :            :         // If there are no errors and the mainloop hook is set, call it.
    1608   [ +  -  +  +  :        117 :         if (ok && m_main_loop_hook)
                   +  + ]
    1609                 :         50 :             ok = run_main_loop_hook();
    1610                 :            : 
    1611                 :            :         // Spin the internal loop until the main loop hook is set or no holds
    1612                 :            :         // remain.
    1613                 :            :         //
    1614                 :            :         // If the main loop returns false we cannot guarantee the state of our
    1615                 :            :         // promise queue (a module promise could be pending) so instead of
    1616                 :            :         // draining the queue we instead just exit.
    1617                 :            :         //
    1618                 :            :         // Additional jobs could have been enqueued from the
    1619                 :            :         // main loop hook
    1620   [ +  -  +  +  :        117 :         if (ok && !m_main_loop.spin(this)) {
                   +  + ]
    1621                 :          3 :             exiting = true;
    1622                 :            :         }
    1623   [ +  -  +  +  :        117 :     } while (ok && !exiting && m_main_loop_hook);
             +  +  +  + ]
    1624                 :            : 
    1625                 :            :     // The promise job queue should be drained even on error, to finish
    1626                 :            :     // outstanding async tasks before the context is torn down. Drain after
    1627                 :            :     // uncaught exceptions have been reported since draining runs callbacks.
    1628                 :            :     // We do not drain if we are exiting.
    1629   [ -  +  -  - ]:        115 :     if (!ok && !exiting) {
    1630                 :          0 :         JS::AutoSaveExceptionState saved_exc(m_cx);
    1631   [ #  #  #  # ]:          0 :         ok = run_jobs_fallible() && ok;
    1632                 :          0 :     }
    1633                 :            : 
    1634                 :        115 :     auto_profile_exit(auto_profile);
    1635                 :            : 
    1636                 :            :     uint8_t out_code;
    1637                 :        115 :     ok = handle_exit_code(ok, "Module", identifier, &out_code, error);
    1638         [ +  + ]:        115 :     if (exit_status_p)
    1639                 :        113 :         *exit_status_p = out_code;
    1640                 :            : 
    1641                 :        115 :     return ok;
    1642                 :        119 : }
    1643                 :            : 
    1644                 :        122 : bool GjsContextPrivate::register_module(const char* identifier, const char* uri,
    1645                 :            :                                         GError** error) {
    1646                 :        122 :     Gjs::AutoMainRealm ar{this};
    1647                 :            : 
    1648         [ +  + ]:        122 :     if (gjs_module_load(m_cx, identifier, uri))
    1649                 :        121 :         return true;
    1650                 :            : 
    1651                 :          1 :     const char* msg = "unknown";
    1652                 :          1 :     JS::ExceptionStack exn_stack(m_cx);
    1653                 :          1 :     JS::ErrorReportBuilder builder(m_cx);
    1654   [ +  -  +  -  :          2 :     if (JS::StealPendingExceptionStack(m_cx, &exn_stack) &&
                   +  - ]
    1655                 :          1 :         builder.init(m_cx, exn_stack,
    1656                 :            :                      JS::ErrorReportBuilder::WithSideEffects)) {
    1657                 :          1 :         msg = builder.toStringResult().c_str();
    1658                 :            :     } else {
    1659                 :          0 :         JS_ClearPendingException(m_cx);
    1660                 :            :     }
    1661                 :            : 
    1662         [ +  - ]:          1 :     g_set_error(error, GJS_ERROR, GJS_ERROR_FAILED,
    1663                 :            :                 "Failed to parse module '%s': %s", identifier,
    1664                 :            :                 msg ? msg : "unknown");
    1665                 :            : 
    1666                 :          1 :     return false;
    1667                 :        122 : }
    1668                 :            : 
    1669                 :            : bool
    1670                 :         62 : gjs_context_eval_file(GjsContext    *js_context,
    1671                 :            :                       const char    *filename,
    1672                 :            :                       int           *exit_status_p,
    1673                 :            :                       GError       **error)
    1674                 :            : {
    1675                 :         62 :     GjsAutoChar script;
    1676                 :            :     size_t script_len;
    1677                 :         62 :     GjsAutoUnref<GFile> file = g_file_new_for_commandline_arg(filename);
    1678                 :            : 
    1679         [ +  + ]:         62 :     if (!g_file_load_contents(file, nullptr, script.out(), &script_len, nullptr,
    1680                 :            :                               error))
    1681                 :          1 :         return false;
    1682                 :            : 
    1683                 :         61 :     return gjs_context_eval(js_context, script, script_len, filename,
    1684                 :         61 :                             exit_status_p, error);
    1685                 :         62 : }
    1686                 :            : 
    1687                 :        114 : bool gjs_context_eval_module_file(GjsContext* js_context, const char* filename,
    1688                 :            :                                   uint8_t* exit_status_p, GError** error) {
    1689                 :        114 :     GjsAutoUnref<GFile> file = g_file_new_for_commandline_arg(filename);
    1690                 :        114 :     GjsAutoChar uri = g_file_get_uri(file);
    1691                 :            : 
    1692   [ +  -  +  + ]:        228 :     return gjs_context_register_module(js_context, uri, uri, error) &&
    1693                 :        114 :            gjs_context_eval_module(js_context, uri, exit_status_p, error);
    1694                 :        114 : }
    1695                 :            : 
    1696                 :            : /*
    1697                 :            :  * GjsContextPrivate::eval_with_scope:
    1698                 :            :  * @scope_object: an object to use as the global scope, or nullptr
    1699                 :            :  * @source: JavaScript program encoded in UTF-8
    1700                 :            :  * @source_len: length of @source, or -1 if @source is 0-terminated
    1701                 :            :  * @filename: filename to use as the origin of @source
    1702                 :            :  * @retval: location for the return value of @source
    1703                 :            :  *
    1704                 :            :  * Executes @source with a local scope so that nothing from the source code
    1705                 :            :  * leaks out into the global scope.
    1706                 :            :  * If @scope_object is given, then everything that @source placed in the global
    1707                 :            :  * namespace is defined on @scope_object.
    1708                 :            :  * Otherwise, the global definitions are just discarded.
    1709                 :            :  */
    1710                 :        251 : bool GjsContextPrivate::eval_with_scope(JS::HandleObject scope_object,
    1711                 :            :                                         const char* source, size_t source_len,
    1712                 :            :                                         const char* filename,
    1713                 :            :                                         JS::MutableHandleValue retval) {
    1714                 :            :     /* log and clear exception if it's set (should not be, normally...) */
    1715         [ -  + ]:        251 :     if (JS_IsExceptionPending(m_cx)) {
    1716                 :          0 :         g_warning("eval_with_scope() called with a pending exception");
    1717                 :          0 :         return false;
    1718                 :            :     }
    1719                 :            : 
    1720                 :        251 :     JS::RootedObject eval_obj(m_cx, scope_object);
    1721         [ +  + ]:        251 :     if (!eval_obj)
    1722                 :        248 :         eval_obj = JS_NewPlainObject(m_cx);
    1723                 :            : 
    1724                 :        251 :     JS::SourceText<mozilla::Utf8Unit> buf;
    1725         [ -  + ]:        251 :     if (!buf.init(m_cx, source, source_len, JS::SourceOwnership::Borrowed))
    1726                 :          0 :         return false;
    1727                 :            : 
    1728                 :        251 :     JS::RootedObjectVector scope_chain(m_cx);
    1729         [ -  + ]:        251 :     if (!scope_chain.append(eval_obj)) {
    1730                 :          0 :         JS_ReportOutOfMemory(m_cx);
    1731                 :          0 :         return false;
    1732                 :            :     }
    1733                 :            : 
    1734                 :        251 :     JS::CompileOptions options(m_cx);
    1735                 :        251 :     options.setFileAndLine(filename, 1).setNonSyntacticScope(true);
    1736                 :            : 
    1737                 :        251 :     GjsAutoUnref<GFile> file = g_file_new_for_commandline_arg(filename);
    1738                 :        251 :     GjsAutoChar uri = g_file_get_uri(file);
    1739                 :        251 :     JS::RootedObject priv(m_cx, gjs_script_module_build_private(m_cx, uri));
    1740         [ -  + ]:        251 :     if (!priv)
    1741                 :          0 :         return false;
    1742                 :            : 
    1743                 :        251 :     JS::RootedScript script(m_cx);
    1744                 :        251 :     script.set(JS::Compile(m_cx, options, buf));
    1745         [ +  + ]:        251 :     if (!script)
    1746                 :          1 :         return false;
    1747                 :            : 
    1748                 :        250 :     JS::SetScriptPrivate(script, JS::ObjectValue(*priv));
    1749         [ +  + ]:        250 :     if (!JS_ExecuteScript(m_cx, scope_chain, script, retval))
    1750                 :         26 :         return false;
    1751                 :            : 
    1752                 :        223 :     schedule_gc_if_needed();
    1753                 :            : 
    1754         [ -  + ]:        223 :     if (JS_IsExceptionPending(m_cx)) {
    1755                 :          0 :         g_warning(
    1756                 :            :             "JS::Evaluate() returned true but exception was pending; "
    1757                 :            :             "did somebody call gjs_throw() without returning false?");
    1758                 :          0 :         return false;
    1759                 :            :     }
    1760                 :            : 
    1761                 :        223 :     gjs_debug(GJS_DEBUG_CONTEXT, "Script evaluation succeeded");
    1762                 :            : 
    1763                 :        223 :     return true;
    1764                 :        250 : }
    1765                 :            : 
    1766                 :            : /*
    1767                 :            :  * GjsContextPrivate::call_function:
    1768                 :            :  * @this_obj: Object to use as the 'this' for the function call
    1769                 :            :  * @func_val: Callable to call, as a JS value
    1770                 :            :  * @args: Arguments to pass to the callable
    1771                 :            :  * @rval: Location for the return value
    1772                 :            :  *
    1773                 :            :  * Use this instead of JS_CallFunctionValue(), because it schedules a GC if
    1774                 :            :  * one is needed. It's good practice to check if a GC should be run every time
    1775                 :            :  * we return from JS back into C++.
    1776                 :            :  */
    1777                 :       2396 : bool GjsContextPrivate::call_function(JS::HandleObject this_obj,
    1778                 :            :                                       JS::HandleValue func_val,
    1779                 :            :                                       const JS::HandleValueArray& args,
    1780                 :            :                                       JS::MutableHandleValue rval) {
    1781         [ +  + ]:       2396 :     if (!JS_CallFunctionValue(m_cx, this_obj, func_val, args, rval))
    1782                 :         18 :         return false;
    1783                 :            : 
    1784                 :       2378 :     schedule_gc_if_needed();
    1785                 :            : 
    1786                 :       2378 :     return true;
    1787                 :            : }
    1788                 :            : 
    1789                 :            : bool
    1790                 :          1 : gjs_context_define_string_array(GjsContext  *js_context,
    1791                 :            :                                 const char    *array_name,
    1792                 :            :                                 gssize         array_length,
    1793                 :            :                                 const char   **array_values,
    1794                 :            :                                 GError       **error)
    1795                 :            : {
    1796                 :          1 :     g_return_val_if_fail(GJS_IS_CONTEXT(js_context), false);
    1797                 :          1 :     GjsContextPrivate* gjs = GjsContextPrivate::from_object(js_context);
    1798                 :            : 
    1799                 :          1 :     Gjs::AutoMainRealm ar{gjs};
    1800                 :            : 
    1801                 :          1 :     std::vector<std::string> strings;
    1802         [ +  - ]:          1 :     if (array_values) {
    1803         [ -  + ]:          1 :         if (array_length < 0)
    1804                 :          0 :             array_length = g_strv_length(const_cast<char**>(array_values));
    1805                 :          3 :         strings = {array_values, array_values + array_length};
    1806                 :            :     }
    1807                 :            : 
    1808                 :            :     // ARGV is a special case to preserve backwards compatibility.
    1809         [ +  - ]:          1 :     if (strcmp(array_name, "ARGV") == 0) {
    1810                 :          1 :         gjs->set_args(std::move(strings));
    1811                 :            : 
    1812                 :          1 :         return true;
    1813                 :            :     }
    1814                 :            : 
    1815                 :          0 :     JS::RootedObject global_root(gjs->context(), gjs->global());
    1816         [ #  # ]:          0 :     if (!gjs_define_string_array(gjs->context(), global_root, array_name,
    1817                 :            :                                  strings, JSPROP_READONLY | JSPROP_PERMANENT)) {
    1818                 :          0 :         gjs_log_exception(gjs->context());
    1819                 :          0 :         g_set_error(error,
    1820                 :            :                     GJS_ERROR,
    1821                 :            :                     GJS_ERROR_FAILED,
    1822                 :            :                     "gjs_define_string_array() failed");
    1823                 :          0 :         return false;
    1824                 :            :     }
    1825                 :            : 
    1826                 :          0 :     return true;
    1827                 :          1 : }
    1828                 :            : 
    1829                 :         53 : void gjs_context_set_argv(GjsContext* js_context, ssize_t array_length,
    1830                 :            :                           const char** array_values) {
    1831                 :         53 :     g_return_if_fail(GJS_IS_CONTEXT(js_context));
    1832                 :         53 :     GjsContextPrivate* gjs = GjsContextPrivate::from_object(js_context);
    1833                 :         53 :     std::vector<std::string> args(array_values, array_values + array_length);
    1834                 :         53 :     gjs->set_args(std::move(args));
    1835                 :         53 : }
    1836                 :            : 
    1837                 :            : static GjsContext *current_context;
    1838                 :            : 
    1839                 :            : GjsContext *
    1840                 :       6457 : gjs_context_get_current (void)
    1841                 :            : {
    1842                 :       6457 :     return current_context;
    1843                 :            : }
    1844                 :            : 
    1845                 :            : void
    1846                 :        482 : gjs_context_make_current (GjsContext *context)
    1847                 :            : {
    1848                 :        482 :     g_assert (context == NULL || current_context == NULL);
    1849                 :            : 
    1850                 :        482 :     current_context = context;
    1851                 :        482 : }
    1852                 :            : 
    1853                 :            : namespace Gjs {
    1854                 :            : /*
    1855                 :            :  * Gjs::AutoMainRealm:
    1856                 :            :  * @gjs: a #GjsContextPrivate
    1857                 :            :  *
    1858                 :            :  * Enters the realm of the "main global" for the context, and leaves when the
    1859                 :            :  * object is destructed at the end of the scope. The main global is the global
    1860                 :            :  * object under which all user JS code is executed. It is used as the root
    1861                 :            :  * object for the scope of modules loaded by GJS in this context.
    1862                 :            :  *
    1863                 :            :  * Only code in a different realm, such as the debugger code or the module
    1864                 :            :  * loader code, uses a different global object.
    1865                 :            :  */
    1866                 :      14170 : AutoMainRealm::AutoMainRealm(GjsContextPrivate* gjs)
    1867                 :      14170 :     : JSAutoRealm(gjs->context(), gjs->global()) {}
    1868                 :            : 
    1869                 :      12810 : AutoMainRealm::AutoMainRealm(JSContext* cx)
    1870                 :      12810 :     : AutoMainRealm(static_cast<GjsContextPrivate*>(JS_GetContextPrivate(cx))) {
    1871                 :      12810 : }
    1872                 :            : 
    1873                 :            : /*
    1874                 :            :  * Gjs::AutoInternalRealm:
    1875                 :            :  * @gjs: a #GjsContextPrivate
    1876                 :            :  *
    1877                 :            :  * Enters the realm of the "internal global" for the context, and leaves when
    1878                 :            :  * the object is destructed at the end of the scope. The internal global is only
    1879                 :            :  * used for executing the module loader code, to keep it separate from user
    1880                 :            :  * code.
    1881                 :            :  */
    1882                 :        484 : AutoInternalRealm::AutoInternalRealm(GjsContextPrivate* gjs)
    1883                 :        484 :     : JSAutoRealm(gjs->context(), gjs->internal_global()) {}
    1884                 :            : 
    1885                 :        242 : AutoInternalRealm::AutoInternalRealm(JSContext* cx)
    1886                 :            :     : AutoInternalRealm(
    1887                 :        242 :           static_cast<GjsContextPrivate*>(JS_GetContextPrivate(cx))) {}
    1888                 :            : 
    1889                 :            : }  // namespace Gjs
    1890                 :            : 
    1891                 :            : /**
    1892                 :            :  * gjs_context_get_profiler:
    1893                 :            :  * @self: the #GjsContext
    1894                 :            :  *
    1895                 :            :  * Returns the profiler's internal instance of #GjsProfiler for you to
    1896                 :            :  * customize, or %NULL if profiling is not enabled on this #GjsContext.
    1897                 :            :  *
    1898                 :            :  * Returns: (transfer none) (nullable): a #GjsProfiler
    1899                 :            :  */
    1900                 :            : GjsProfiler *
    1901                 :          4 : gjs_context_get_profiler(GjsContext *self)
    1902                 :            : {
    1903                 :          4 :     return GjsContextPrivate::from_object(self)->profiler();
    1904                 :            : }
    1905                 :            : 
    1906                 :            : /**
    1907                 :            :  * gjs_get_js_version:
    1908                 :            :  *
    1909                 :            :  * Returns the underlying version of the JS engine.
    1910                 :            :  *
    1911                 :            :  * Returns: a string
    1912                 :            :  */
    1913                 :            : const char *
    1914                 :          2 : gjs_get_js_version(void)
    1915                 :            : {
    1916                 :          2 :     return JS_GetImplementationVersion();
    1917                 :            : }
    1918                 :            : 
    1919                 :            : /**
    1920                 :            :  * gjs_context_run_in_realm:
    1921                 :            :  * @self: the #GjsContext
    1922                 :            :  * @func: (scope call): function to run
    1923                 :            :  * @user_data: (closure func): pointer to pass to @func
    1924                 :            :  *
    1925                 :            :  * Runs @func immediately, not asynchronously, after entering the JS context's
    1926                 :            :  * main realm. After @func completes, leaves the realm again.
    1927                 :            :  *
    1928                 :            :  * You only need this if you are using JSAPI calls from the SpiderMonkey API
    1929                 :            :  * directly.
    1930                 :            :  */
    1931                 :          1 : void gjs_context_run_in_realm(GjsContext* self, GjsContextInRealmFunc func,
    1932                 :            :                               void* user_data) {
    1933                 :          1 :     g_return_if_fail(GJS_IS_CONTEXT(self));
    1934                 :          1 :     g_return_if_fail(func);
    1935                 :            : 
    1936                 :          1 :     GjsContextPrivate* gjs = GjsContextPrivate::from_object(self);
    1937                 :          1 :     Gjs::AutoMainRealm ar{gjs};
    1938                 :          1 :     func(self, user_data);
    1939                 :          1 : }

Generated by: LCOV version 1.14