1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 04:27:45 +00:00

LibWeb: Add the WritableStream interface

This commit is contained in:
Matthew Olsson 2023-04-02 15:15:53 -07:00 committed by Linus Groh
parent 78feba401d
commit e93560b769
10 changed files with 311 additions and 0 deletions

View file

@ -0,0 +1,132 @@
/*
* Copyright (c) 2023, Matthew Olsson <mattco@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Forward.h>
#include <AK/SinglyLinkedList.h>
#include <LibJS/Forward.h>
#include <LibWeb/Bindings/PlatformObject.h>
#include <LibWeb/Forward.h>
#include <LibWeb/WebIDL/Promise.h>
namespace Web::Streams {
// https://streams.spec.whatwg.org/#pending-abort-request
struct PendingAbortRequest {
// https://streams.spec.whatwg.org/#pending-abort-request-promise
// A promise returned from WritableStreamAbort
JS::NonnullGCPtr<WebIDL::Promise> promise;
// https://streams.spec.whatwg.org/#pending-abort-request-reason
// A JavaScript value that was passed as the abort reason to WritableStreamAbort
JS::Value reason;
// https://streams.spec.whatwg.org/#pending-abort-request-was-already-erroring
// A boolean indicating whether or not the stream was in the "erroring" state when WritableStreamAbort was called, which impacts the outcome of the abort request
bool was_already_erroring;
};
// https://streams.spec.whatwg.org/#writablestream
class WritableStream final : public Bindings::PlatformObject {
WEB_PLATFORM_OBJECT(WritableStream, Bindings::PlatformObject);
public:
enum class State {
Writable,
Closed,
Erroring,
Errored,
};
static WebIDL::ExceptionOr<JS::NonnullGCPtr<WritableStream>> construct_impl(JS::Realm& realm, Optional<JS::Handle<JS::Object>> const& underlying_sink);
virtual ~WritableStream() = default;
bool locked() const;
bool backpressure() const { return m_backpressure; }
void set_backpressure(bool value) { m_backpressure = value; }
JS::GCPtr<WebIDL::Promise const> close_request() const { return m_close_request; }
void set_close_request(JS::GCPtr<WebIDL::Promise> value) { m_close_request = value; }
JS::GCPtr<JS::Object> controller() { return m_controller; }
void set_controller(JS::GCPtr<JS::Object> value) { m_controller = value; }
JS::GCPtr<WebIDL::Promise const> in_flight_write_request() const { return m_in_flight_write_request; }
void set_in_flight_write_request(JS::GCPtr<WebIDL::Promise> value) { m_in_flight_write_request = value; }
JS::GCPtr<WebIDL::Promise const> in_flight_close_request() const { return m_in_flight_close_request; }
void set_in_flight_close_request(JS::GCPtr<WebIDL::Promise> value) { m_in_flight_close_request = value; }
Optional<PendingAbortRequest>& pending_abort_request() { return m_pending_abort_request; }
void set_pending_abort_request(Optional<PendingAbortRequest>&& value) { m_pending_abort_request = move(value); }
State state() const { return m_state; }
void set_state(State value) { m_state = value; }
JS::Value stored_error() const { return m_stored_error; }
void set_stored_error(JS::Value value) { m_stored_error = value; }
JS::GCPtr<JS::Object const> writer() const { return m_writer; }
void set_writer(JS::GCPtr<JS::Object> value) { m_writer = value; }
SinglyLinkedList<JS::NonnullGCPtr<WebIDL::Promise>>& write_requests() { return m_write_requests; }
private:
explicit WritableStream(JS::Realm&);
virtual JS::ThrowCompletionOr<void> initialize(JS::Realm&) override;
virtual void visit_edges(Cell::Visitor&) override;
// https://streams.spec.whatwg.org/#writablestream-backpressure
// A boolean indicating the backpressure signal set by the controller
bool m_backpressure { false };
// https://streams.spec.whatwg.org/#writablestream-closerequest
// The promise returned from the writers close() method
JS::GCPtr<WebIDL::Promise> m_close_request;
// https://streams.spec.whatwg.org/#writablestream-controller
// A WritableStreamDefaultController created with the ability to control the state and queue of this stream
JS::GCPtr<JS::Object> m_controller;
// https://streams.spec.whatwg.org/#writablestream-detached
// A boolean flag set to true when the stream is transferred
bool m_detached { false };
// https://streams.spec.whatwg.org/#writablestream-inflightwriterequest
// A slot set to the promise for the current in-flight write operation while the underlying sink's write algorithm is executing and has not yet fulfilled, used to prevent reentrant calls
JS::GCPtr<WebIDL::Promise> m_in_flight_write_request;
// https://streams.spec.whatwg.org/#writablestream-inflightcloserequest
// A slot set to the promise for the current in-flight close operation while the underlying sink's close algorithm is executing and has not yet fulfilled, used to prevent the abort() method from interrupting close
JS::GCPtr<WebIDL::Promise> m_in_flight_close_request;
// https://streams.spec.whatwg.org/#writablestream-pendingabortrequest
// A pending abort request
Optional<PendingAbortRequest> m_pending_abort_request;
// https://streams.spec.whatwg.org/#writablestream-state
// A string containing the streams current state, used internally; one of "writable", "closed", "erroring", or "errored"
State m_state { State::Writable };
// https://streams.spec.whatwg.org/#writablestream-storederror
// A value indicating how the stream failed, to be given as a failure reason or exception when trying to operate on the stream while in the "errored" state
JS::Value m_stored_error { JS::js_undefined() };
// https://streams.spec.whatwg.org/#writablestream-writer
// A WritableStreamDefaultWriter instance, if the stream is locked to a writer, or undefined if it is not
JS::GCPtr<JS::Object> m_writer;
// https://streams.spec.whatwg.org/#writablestream-writerequests
// A list of promises representing the streams internal queue of write requests not yet processed by the underlying sink
SinglyLinkedList<JS::NonnullGCPtr<WebIDL::Promise>> m_write_requests;
};
}