LibWeb: Implement 'fetch params' struct

Userland/Libraries/LibWeb/CMakeLists.txt

@@ -127,6 +127,7 @@ set(SOURCES
     Fetch/Infrastructure/ConnectionTimingInfo.cpp
     Fetch/Infrastructure/FetchAlgorithms.cpp
     Fetch/Infrastructure/FetchController.cpp
+    Fetch/Infrastructure/FetchParams.cpp
     Fetch/Infrastructure/FetchTimingInfo.cpp
     Fetch/Infrastructure/HTTP.cpp
     Fetch/Infrastructure/HTTP/Bodies.cpp

Userland/Libraries/LibWeb/Fetch/Infrastructure/FetchParams.cpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2022, Linus Groh <linusg@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <LibJS/Heap/Heap.h>
+#include <LibJS/Runtime/VM.h>
+#include <LibWeb/Fetch/Infrastructure/FetchParams.h>
+#include <LibWeb/Fetch/Infrastructure/HTTP/Responses.h>
+
+namespace Web::Fetch::Infrastructure {
+
+FetchParams::FetchParams(JS::NonnullGCPtr<Request> request, JS::NonnullGCPtr<FetchAlgorithms> algorithms, JS::NonnullGCPtr<FetchController> controller, JS::NonnullGCPtr<FetchTimingInfo> timing_info)
+    : m_request(request)
+    , m_algorithms(algorithms)
+    , m_controller(controller)
+    , m_timing_info(timing_info)
+{
+}
+
+JS::NonnullGCPtr<FetchParams> FetchParams::create(JS::VM& vm, JS::NonnullGCPtr<Request> request, JS::NonnullGCPtr<FetchTimingInfo> timing_info)
+{
+    auto algorithms = Infrastructure::FetchAlgorithms::create(vm, {});
+    auto controller = Infrastructure::FetchController::create(vm);
+    return { *vm.heap().allocate_without_realm<FetchParams>(request, algorithms, controller, timing_info) };
+}
+
+void FetchParams::visit_edges(JS::Cell::Visitor& visitor)
+{
+    Base::visit_edges(visitor);
+    visitor.visit(m_request);
+    visitor.visit(m_algorithms);
+    visitor.visit(m_controller);
+    visitor.visit(m_timing_info);
+    if (m_task_destination.has<JS::NonnullGCPtr<JS::Object>>())
+        visitor.visit(m_task_destination.get<JS::NonnullGCPtr<JS::Object>>());
+    if (m_preloaded_response_candidate.has<JS::NonnullGCPtr<Response>>())
+        visitor.visit(m_preloaded_response_candidate.get<JS::NonnullGCPtr<Response>>());
+}
+
+// https://fetch.spec.whatwg.org/#fetch-params-aborted
+bool FetchParams::is_aborted() const
+{
+    // A fetch params fetchParams is aborted if its controller’s state is "aborted".
+    return m_controller->state() == FetchController::State::Aborted;
+}
+
+// https://fetch.spec.whatwg.org/#fetch-params-canceled
+bool FetchParams::is_canceled() const
+{
+    // A fetch params fetchParams is canceled if its controller’s state is "aborted" or "terminated".
+    return m_controller->state() == FetchController::State::Aborted || m_controller->state() == FetchController::State::Terminated;
+}
+
+}

Userland/Libraries/LibWeb/Fetch/Infrastructure/FetchParams.h

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2022, Linus Groh <linusg@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Forward.h>
+#include <LibJS/Forward.h>
+#include <LibJS/Heap/Cell.h>
+#include <LibWeb/Fetch/Infrastructure/FetchAlgorithms.h>
+#include <LibWeb/Fetch/Infrastructure/FetchController.h>
+#include <LibWeb/Fetch/Infrastructure/FetchTimingInfo.h>
+#include <LibWeb/Fetch/Infrastructure/HTTP/Requests.h>
+
+namespace Web::Fetch::Infrastructure {
+
+// https://fetch.spec.whatwg.org/#fetch-params
+class FetchParams : public JS::Cell {
+    JS_CELL(FetchParams, JS::Cell);
+
+public:
+    // FIXME: 'or a parallel queue'
+    using TaskDestination = Variant<Empty, JS::NonnullGCPtr<JS::Object>>;
+
+    struct PreloadedResponseCandidatePendingTag { };
+    using PreloadedResponseCandidate = Variant<Empty, PreloadedResponseCandidatePendingTag, JS::NonnullGCPtr<Response>>;
+
+    [[nodiscard]] static JS::NonnullGCPtr<FetchParams> create(JS::VM&, JS::NonnullGCPtr<Request>, JS::NonnullGCPtr<FetchTimingInfo>);
+
+    [[nodiscard]] JS::NonnullGCPtr<Request> request() const { return m_request; }
+    [[nodiscard]] JS::NonnullGCPtr<FetchController> controller() const { return m_controller; }
+    [[nodiscard]] JS::NonnullGCPtr<FetchTimingInfo> timing_info() const { return m_timing_info; }
+
+    [[nodiscard]] JS::NonnullGCPtr<FetchAlgorithms> algorithms() const { return m_algorithms; }
+    void set_algorithms(JS::NonnullGCPtr<FetchAlgorithms> algorithms) { m_algorithms = algorithms; }
+
+    [[nodiscard]] TaskDestination& task_destination() { return m_task_destination; }
+    [[nodiscard]] TaskDestination const& task_destination() const { return m_task_destination; }
+    void set_task_destination(TaskDestination task_destination) { m_task_destination = move(task_destination); }
+
+    [[nodiscard]] HTML::CanUseCrossOriginIsolatedAPIs cross_origin_isolated_capability() const { return m_cross_origin_isolated_capability; }
+    void set_cross_origin_isolated_capability(HTML::CanUseCrossOriginIsolatedAPIs cross_origin_isolated_capability) { m_cross_origin_isolated_capability = cross_origin_isolated_capability; }
+
+    [[nodiscard]] PreloadedResponseCandidate& preloaded_response_candidate() { return m_preloaded_response_candidate; }
+    [[nodiscard]] PreloadedResponseCandidate const& preloaded_response_candidate() const { return m_preloaded_response_candidate; }
+    void set_preloaded_response_candidate(PreloadedResponseCandidate preloaded_response_candidate) { m_preloaded_response_candidate = move(preloaded_response_candidate); }
+
+    [[nodiscard]] bool is_aborted() const;
+    [[nodiscard]] bool is_canceled() const;
+
+private:
+    FetchParams(JS::NonnullGCPtr<Request>, JS::NonnullGCPtr<FetchAlgorithms>, JS::NonnullGCPtr<FetchController>, JS::NonnullGCPtr<FetchTimingInfo>);
+
+    virtual void visit_edges(JS::Cell::Visitor&) override;
+
+    // https://fetch.spec.whatwg.org/#fetch-params-request
+    // request
+    //     A request.
+    JS::NonnullGCPtr<Request> m_request;
+
+    // https://fetch.spec.whatwg.org/#fetch-params-process-request-body
+    // process request body chunk length (default null)
+    // https://fetch.spec.whatwg.org/#fetch-params-process-request-end-of-body
+    // process request end-of-body (default null)
+    // https://fetch.spec.whatwg.org/#fetch-params-process-early-hints-response
+    // process early hints response (default null)
+    // https://fetch.spec.whatwg.org/#fetch-params-process-response
+    // process response (default null)
+    // https://fetch.spec.whatwg.org/#fetch-params-process-response-end-of-body
+    // process response end-of-body (default null)
+    // https://fetch.spec.whatwg.org/#fetch-params-process-response-consume-body
+    // process response consume body (default null)
+    //     Null or an algorithm.
+    JS::NonnullGCPtr<FetchAlgorithms> m_algorithms;
+
+    // https://fetch.spec.whatwg.org/#fetch-params-task-destination
+    // task destination (default null)
+    //     Null, a global object, or a parallel queue.
+    TaskDestination m_task_destination;
+
+    // https://fetch.spec.whatwg.org/#fetch-params-cross-origin-isolated-capability
+    // cross-origin isolated capability (default false)
+    //     A boolean.
+    HTML::CanUseCrossOriginIsolatedAPIs m_cross_origin_isolated_capability { HTML::CanUseCrossOriginIsolatedAPIs::No };
+
+    // https://fetch.spec.whatwg.org/#fetch-params-controller
+    // controller (default a new fetch controller)
+    //     A fetch controller.
+    JS::NonnullGCPtr<FetchController> m_controller;
+
+    // https://fetch.spec.whatwg.org/#fetch-params-timing-info
+    // timing info
+    //     A fetch timing info.
+    JS::NonnullGCPtr<FetchTimingInfo> m_timing_info;
+
+    // https://fetch.spec.whatwg.org/#fetch-params-preloaded-response-candidate
+    // preloaded response candidate (default null)
+    //     Null, "pending", or a response.
+    PreloadedResponseCandidate m_preloaded_response_candidate;
+};
+
+}

Userland/Libraries/LibWeb/Forward.h

@@ -195,6 +195,7 @@ struct BodyWithType;
 class ConnectionTimingInfo;
 class FetchAlgorithms;
 class FetchController;
+class FetchParams;
 class FetchTimingInfo;
 struct Header;
 class HeaderList;