LibWeb: Move timer implementations to WindowOrWorkerGlobalScopeMixin

This is where it belongs according to the spec, and where these methods'
IDL will be placed.

This forces us to implement a few steps closer to the spec as well.

Userland/Libraries/LibWeb/HTML/WindowOrWorkerGlobalScope.cpp

@@ -10,12 +10,15 @@
 #include <AK/Utf8View.h>
 #include <AK/Vector.h>
 #include <LibTextCodec/Decoder.h>
+#include <LibWeb/Bindings/MainThreadVM.h>
 #include <LibWeb/Fetch/FetchMethod.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/HTML/EventLoop/EventLoop.h>
+#include <LibWeb/HTML/Scripting/ClassicScript.h>
 #include <LibWeb/HTML/Scripting/Environments.h>
 #include <LibWeb/HTML/Scripting/ExceptionReporter.h>
 #include <LibWeb/HTML/StructuredSerialize.h>
+#include <LibWeb/HTML/Timer.h>
 #include <LibWeb/HTML/Window.h>
 #include <LibWeb/HTML/WindowOrWorkerGlobalScope.h>
 #include <LibWeb/Infra/Base64.h>
@@ -27,6 +30,12 @@ namespace Web::HTML {
 
 WindowOrWorkerGlobalScopeMixin::~WindowOrWorkerGlobalScopeMixin() = default;
 
+void WindowOrWorkerGlobalScopeMixin::visit_edges(JS::Cell::Visitor& visitor)
+{
+    for (auto& it : m_timers)
+        visitor.visit(it.value);
+}
+
 // https://html.spec.whatwg.org/multipage/webappapis.html#dom-origin
 WebIDL::ExceptionOr<String> WindowOrWorkerGlobalScopeMixin::origin() const
 {
@@ -132,4 +141,127 @@ JS::NonnullGCPtr<JS::Promise> WindowOrWorkerGlobalScopeMixin::fetch(Fetch::Reque
     return Fetch::fetch(vm, input, init);
 }
 
+// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-settimeout
+i32 WindowOrWorkerGlobalScopeMixin::set_timeout(TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments)
+{
+    return run_timer_initialization_steps(move(handler), timeout, move(arguments), Repeat::No);
+}
+
+// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval
+i32 WindowOrWorkerGlobalScopeMixin::set_interval(TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments)
+{
+    return run_timer_initialization_steps(move(handler), timeout, move(arguments), Repeat::Yes);
+}
+
+// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-cleartimeout
+void WindowOrWorkerGlobalScopeMixin::clear_timeout(i32 id)
+{
+    m_timers.remove(id);
+}
+
+// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-clearinterval
+void WindowOrWorkerGlobalScopeMixin::clear_interval(i32 id)
+{
+    m_timers.remove(id);
+}
+
+// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timer-initialisation-steps
+i32 WindowOrWorkerGlobalScopeMixin::run_timer_initialization_steps(TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments, Repeat repeat, Optional<i32> previous_id, Optional<AK::URL> base_url)
+{
+    // 1. Let thisArg be global if that is a WorkerGlobalScope object; otherwise let thisArg be the WindowProxy that corresponds to global.
+
+    // 2. If previousId was given, let id be previousId; otherwise, let id be an implementation-defined integer that is greater than zero and does not already exist in global's map of active timers.
+    auto id = previous_id.has_value() ? previous_id.value() : m_timer_id_allocator.allocate();
+
+    // FIXME: 3. If the surrounding agent's event loop's currently running task is a task that was created by this algorithm, then let nesting level be the task's timer nesting level. Otherwise, let nesting level be zero.
+
+    // 4. If timeout is less than 0, then set timeout to 0.
+    if (timeout < 0)
+        timeout = 0;
+
+    // FIXME: 5. If nesting level is greater than 5, and timeout is less than 4, then set timeout to 4.
+
+    // 6. Let callerRealm be the current Realm Record, and calleeRealm be global's relevant Realm.
+    // FIXME: Implement this when step 9.3.2 is implemented.
+
+    // FIXME: The active script becomes null on repeated setInterval callbacks. In JS::VM::get_active_script_or_module,
+    //        the execution context stack is empty on the repeated invocations, thus it returns null. We will need
+    //        to figure out why it becomes empty. But all we need from the active script is the base URL, so we
+    //        grab it on the first invocation an reuse it on repeated invocations.
+    if (!base_url.has_value()) {
+        // 7. Let initiating script be the active script.
+        auto const* initiating_script = Web::Bindings::active_script();
+
+        // 8. Assert: initiating script is not null, since this algorithm is always called from some script.
+        VERIFY(initiating_script);
+
+        base_url = initiating_script->base_url();
+    }
+
+    // 9. Let task be a task that runs the following substeps:
+    JS::SafeFunction<void()> task = [this, handler = move(handler), timeout, arguments = move(arguments), repeat, id, base_url = move(base_url)]() mutable {
+        // 1. If id does not exist in global's map of active timers, then abort these steps.
+        if (!m_timers.contains(id))
+            return;
+
+        handler.visit(
+            // 2. If handler is a Function, then invoke handler given arguments with the callback this value set to thisArg. If this throws an exception, catch it, and report the exception.
+            [&](JS::Handle<WebIDL::CallbackType> const& callback) {
+                if (auto result = WebIDL::invoke_callback(*callback, &this_impl(), arguments); result.is_error())
+                    report_exception(result, this_impl().realm());
+            },
+            // 3. Otherwise:
+            [&](DeprecatedString const& source) {
+                // 1. Assert: handler is a string.
+                // FIXME: 2. Perform HostEnsureCanCompileStrings(callerRealm, calleeRealm). If this throws an exception, catch it, report the exception, and abort these steps.
+
+                // 3. Let settings object be global's relevant settings object.
+                auto& settings_object = relevant_settings_object(this_impl());
+
+                // 4. Let base URL be initiating script's base URL.
+                // 5. Assert: base URL is not null, as initiating script is a classic script or a JavaScript module script.
+                VERIFY(base_url.has_value());
+
+                // 6. Let fetch options be a script fetch options whose cryptographic nonce is initiating script's fetch options's cryptographic nonce, integrity metadata is the empty string, parser metadata is "not-parser-inserted", credentials mode is initiating script's fetch options's credentials mode, and referrer policy is initiating script's fetch options's referrer policy.
+                // 7. Let script be the result of creating a classic script given handler, settings object, base URL, and fetch options.
+                auto script = ClassicScript::create(base_url->basename(), source, settings_object, *base_url);
+
+                // 8. Run the classic script script.
+                (void)script->run();
+            });
+
+        // 4. If id does not exist in global's map of active timers, then abort these steps.
+        if (!m_timers.contains(id))
+            return;
+
+        switch (repeat) {
+        // 5. If repeat is true, then perform the timer initialization steps again, given global, handler, timeout, arguments, true, and id.
+        case Repeat::Yes:
+            run_timer_initialization_steps(handler, timeout, move(arguments), repeat, id, move(base_url));
+            break;
+
+        // 6. Otherwise, remove global's map of active timers[id].
+        case Repeat::No:
+            m_timers.remove(id);
+            break;
+        }
+    };
+
+    // FIXME: 10. Increment nesting level by one.
+    // FIXME: 11. Set task's timer nesting level to nesting level.
+
+    // 12. Let completionStep be an algorithm step which queues a global task on the timer task source given global to run task.
+    JS::SafeFunction<void()> completion_step = [this, task = move(task)]() mutable {
+        queue_global_task(Task::Source::TimerTask, this_impl(), move(task));
+    };
+
+    // 13. Run steps after a timeout given global, "setTimeout/setInterval", timeout, completionStep, and id.
+    auto timer = Timer::create(this_impl(), timeout, move(completion_step), id);
+    m_timers.set(id, timer);
+    timer->start();
+
+    // 14. Return id.
+    return id;
+}
+
 }