Everywhere: Hoist the Libraries folder to the top-level

Author: https://github.com/trflynn89 Commit: 93712b24bf Pull-request: https://github.com/LadybirdBrowser/ladybird/pull/2256 Reviewed-by: https://github.com/sideshowbarker
2025-07-19 15:32:31 +00:00 · 2024-11-09 12:25:08 -05:00 · 2024-11-09 12:25:08 -05:00 · 93712b24bf · 2024-11-10 11:51:52 +00:00
commit 93712b24bf
parent 950e819ee7
4547 changed files with 104 additions and 113 deletions
--- a/Libraries/LibWeb/WebDriver/ExecuteScript.cpp
+++ b/Libraries/LibWeb/WebDriver/ExecuteScript.cpp
@ -0,0 +1,240 @@
+/*
+ * Copyright (c) 2022-2023, Linus Groh <linusg@serenityos.org>
+ * Copyright (c) 2024, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <LibJS/Parser.h>
+#include <LibJS/Runtime/ECMAScriptFunctionObject.h>
+#include <LibJS/Runtime/GlobalEnvironment.h>
+#include <LibJS/Runtime/ObjectEnvironment.h>
+#include <LibJS/Runtime/PromiseConstructor.h>
+#include <LibWeb/DOM/Document.h>
+#include <LibWeb/HTML/BrowsingContext.h>
+#include <LibWeb/HTML/Scripting/Environments.h>
+#include <LibWeb/HTML/Scripting/TemporaryExecutionContext.h>
+#include <LibWeb/HTML/Window.h>
+#include <LibWeb/Platform/EventLoopPlugin.h>
+#include <LibWeb/WebDriver/ExecuteScript.h>
+#include <LibWeb/WebDriver/HeapTimer.h>
+
+namespace Web::WebDriver {
+
+// https://w3c.github.io/webdriver/#dfn-execute-a-function-body
+static JS::ThrowCompletionOr<JS::Value> execute_a_function_body(HTML::BrowsingContext const& browsing_context, ByteString const& body, ReadonlySpan<JS::Value> parameters)
+{
+    // 1. Let window be the associated window of the current browsing context’s active document.
+    auto window = browsing_context.active_document()->window();
+
+    // 2. Let environment settings be the environment settings object for window.
+    auto& environment_settings = Web::HTML::relevant_settings_object(*window);
+
+    // 3. Let global scope be environment settings realm’s global environment.
+    auto& realm = environment_settings.realm();
+    auto& global_scope = realm.global_environment();
+
+    auto source_text = ByteString::formatted(
+        R"~~~(function() {{
+            {}
+        }})~~~",
+        body);
+
+    auto parser = JS::Parser { JS::Lexer { source_text } };
+    auto function_expression = parser.parse_function_node<JS::FunctionExpression>();
+
+    // 4. If body is not parsable as a FunctionBody or if parsing detects an early error, return Completion { [[Type]]: normal, [[Value]]: null, [[Target]]: empty }.
+    if (parser.has_errors())
+        return JS::js_null();
+
+    // 5. If body begins with a directive prologue that contains a use strict directive then let strict be true, otherwise let strict be false.
+    // NOTE: Handled in step 8 below.
+
+    // 6. Prepare to run a script with realm.
+    HTML::prepare_to_run_script(realm);
+
+    // 7. Prepare to run a callback with environment settings.
+    HTML::prepare_to_run_callback(realm);
+
+    // 8. Let function be the result of calling FunctionCreate, with arguments:
+    // kind
+    //    Normal.
+    // list
+    //    An empty List.
+    // body
+    //    The result of parsing body above.
+    // global scope
+    //    The result of parsing global scope above.
+    // strict
+    //    The result of parsing strict above.
+    auto function = JS::ECMAScriptFunctionObject::create(realm, "", move(source_text), function_expression->body(), function_expression->parameters(), function_expression->function_length(), function_expression->local_variables_names(), &global_scope, nullptr, function_expression->kind(), function_expression->is_strict_mode(), function_expression->parsing_insights());
+
+    // 9. Let completion be Function.[[Call]](window, parameters) with function as the this value.
+    // NOTE: This is not entirely clear, but I don't think they mean actually passing `function` as
+    // the this value argument, but using it as the object [[Call]] is executed on.
+    auto completion = function->internal_call(window, parameters);
+
+    // 10. Clean up after running a callback with environment settings.
+    HTML::clean_up_after_running_callback(realm);
+
+    // 11. Clean up after running a script with realm.
+    HTML::clean_up_after_running_script(realm);
+
+    // 12. Return completion.
+    return completion;
+}
+
+void execute_script(HTML::BrowsingContext const& browsing_context, ByteString body, JS::MarkedVector<JS::Value> arguments, Optional<u64> const& timeout_ms, JS::NonnullGCPtr<OnScriptComplete> on_complete)
+{
+    auto const* document = browsing_context.active_document();
+    auto& realm = document->realm();
+    auto& vm = document->vm();
+
+    // 5. Let timer be a new timer.
+    auto timer = vm.heap().allocate<HeapTimer>(realm);
+
+    // 6. If timeout is not null:
+    if (timeout_ms.has_value()) {
+        // 1. Start the timer with timer and timeout.
+        timer->start(timeout_ms.value(), JS::create_heap_function(vm.heap(), [on_complete]() {
+            on_complete->function()({ .state = JS::Promise::State::Pending });
+        }));
+    }
+
+    // AD-HOC: An execution context is required for Promise creation hooks.
+    HTML::TemporaryExecutionContext execution_context { realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
+
+    // 7. Let promise be a new Promise.
+    auto promise = WebIDL::create_promise(realm);
+
+    // 8. Run the following substeps in parallel:
+    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, &browsing_context, promise, body = move(body), arguments = move(arguments)]() mutable {
+        HTML::TemporaryExecutionContext execution_context { realm };
+
+        // 1. Let scriptPromise be the result of promise-calling execute a function body, with arguments body and arguments.
+        auto script_result = execute_a_function_body(browsing_context, body, move(arguments));
+
+        // FIXME: This isn't right, we should be reacting to this using WebIDL::react_to_promise()
+        // 2. Upon fulfillment of scriptPromise with value v, resolve promise with value v.
+        if (script_result.has_value()) {
+            WebIDL::resolve_promise(realm, promise, script_result.release_value());
+        }
+
+        // 3. Upon rejection of scriptPromise with value r, reject promise with value r.
+        if (script_result.is_throw_completion()) {
+            WebIDL::reject_promise(realm, promise, *script_result.throw_completion().value());
+        }
+    }));
+
+    // 9. Wait until promise is resolved, or timer's timeout fired flag is set, whichever occurs first.
+    auto reaction_steps = JS::create_heap_function(vm.heap(), [promise, timer, on_complete](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+        if (timer->is_timed_out())
+            return JS::js_undefined();
+        timer->stop();
+
+        auto promise_promise = JS::NonnullGCPtr { verify_cast<JS::Promise>(*promise->promise()) };
+        on_complete->function()({ promise_promise->state(), promise_promise->result() });
+
+        return JS::js_undefined();
+    });
+
+    WebIDL::react_to_promise(promise, reaction_steps, reaction_steps);
+}
+
+void execute_async_script(HTML::BrowsingContext const& browsing_context, ByteString body, JS::MarkedVector<JS::Value> arguments, Optional<u64> const& timeout_ms, JS::NonnullGCPtr<OnScriptComplete> on_complete)
+{
+    auto const* document = browsing_context.active_document();
+    auto& realm = document->realm();
+    auto& vm = document->vm();
+
+    // 5. Let timer be a new timer.
+    auto timer = vm.heap().allocate<HeapTimer>(realm);
+
+    // 6. If timeout is not null:
+    if (timeout_ms.has_value()) {
+        // 1. Start the timer with timer and timeout.
+        timer->start(timeout_ms.value(), JS::create_heap_function(vm.heap(), [on_complete]() {
+            on_complete->function()({ .state = JS::Promise::State::Pending });
+        }));
+    }
+
+    // AD-HOC: An execution context is required for Promise creation hooks.
+    HTML::TemporaryExecutionContext execution_context { realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
+
+    // 7. Let promise be a new Promise.
+    auto promise_capability = WebIDL::create_promise(realm);
+    JS::NonnullGCPtr promise { verify_cast<JS::Promise>(*promise_capability->promise()) };
+
+    // 8. Run the following substeps in parallel:
+    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&vm, &realm, &browsing_context, timer, promise_capability, promise, body = move(body), arguments = move(arguments)]() mutable {
+        HTML::TemporaryExecutionContext execution_context { realm };
+
+        // 1. Let resolvingFunctions be CreateResolvingFunctions(promise).
+        auto resolving_functions = promise->create_resolving_functions();
+
+        // 2. Append resolvingFunctions.[[Resolve]] to arguments.
+        arguments.append(resolving_functions.resolve);
+
+        // 3. Let result be the result of calling execute a function body, with arguments body and arguments.
+        // FIXME: 'result' -> 'scriptResult' (spec issue)
+        auto script_result = execute_a_function_body(browsing_context, body, move(arguments));
+
+        // 4. If scriptResult.[[Type]] is not normal, then reject promise with value scriptResult.[[Value]], and abort these steps.
+        // NOTE: Prior revisions of this specification did not recognize the return value of the provided script.
+        //       In order to preserve legacy behavior, the return value only influences the command if it is a
+        //       "thenable"  object or if determining this produces an exception.
+        if (script_result.is_throw_completion()) {
+            promise->reject(*script_result.throw_completion().value());
+            return;
+        }
+
+        // 5. If Type(scriptResult.[[Value]]) is not Object, then abort these steps.
+        if (!script_result.value().is_object())
+            return;
+
+        // 6. Let then be Get(scriptResult.[[Value]], "then").
+        auto then = script_result.value().as_object().get(vm.names.then);
+
+        // 7. If then.[[Type]] is not normal, then reject promise with value then.[[Value]], and abort these steps.
+        if (then.is_throw_completion()) {
+            promise->reject(*then.throw_completion().value());
+            return;
+        }
+
+        // 8. If IsCallable(then.[[Type]]) is false, then abort these steps.
+        if (!then.value().is_function())
+            return;
+
+        // 9. Let scriptPromise be PromiseResolve(Promise, scriptResult.[[Value]]).
+        auto script_promise_or_error = JS::promise_resolve(vm, realm.intrinsics().promise_constructor(), script_result.value());
+        if (script_promise_or_error.is_throw_completion())
+            return;
+        auto& script_promise = static_cast<JS::Promise&>(*script_promise_or_error.value());
+
+        vm.custom_data()->spin_event_loop_until(JS::create_heap_function(vm.heap(), [timer, &script_promise]() {
+            return timer->is_timed_out() || script_promise.state() != JS::Promise::State::Pending;
+        }));
+
+        // 10. Upon fulfillment of scriptPromise with value v, resolve promise with value v.
+        if (script_promise.state() == JS::Promise::State::Fulfilled)
+            WebIDL::resolve_promise(realm, promise_capability, script_promise.result());
+
+        // 11. Upon rejection of scriptPromise with value r, reject promise with value r.
+        if (script_promise.state() == JS::Promise::State::Rejected)
+            WebIDL::reject_promise(realm, promise_capability, script_promise.result());
+    }));
+
+    // 9. Wait until promise is resolved, or timer's timeout fired flag is set, whichever occurs first.
+    auto reaction_steps = JS::create_heap_function(vm.heap(), [promise, timer, on_complete](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+        if (timer->is_timed_out())
+            return JS::js_undefined();
+        timer->stop();
+
+        on_complete->function()({ promise->state(), promise->result() });
+        return JS::js_undefined();
+    });
+
+    WebIDL::react_to_promise(promise_capability, reaction_steps, reaction_steps);
+}
+
+}