Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-23 01:23:19 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Bodies.h

82 lines
3.3 KiB
C
Raw Normal View History

LibWeb: Add definitions from '2.2.4. Bodies' in the Fetch spec ...at least the ones that don't require an implementation of the Streams spec :^)
2022-07-12 18:04:24 +01:00
/*
LibWeb/Fetch: Port infrastructure to new String
2023-03-02 23:26:35 +00:00
* Copyright (c) 2022-2023, Linus Groh <linusg@serenityos.org>
LibWeb: Add definitions from '2.2.4. Bodies' in the Fetch spec ...at least the ones that don't require an implementation of the Streams spec :^)
2022-07-12 18:04:24 +01:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/ByteBuffer.h>
#include <AK/Forward.h>
LibWeb: Add Blob to Fetch's Body::SourceType variant
2022-07-18 08:09:11 +01:00
#include <AK/NonnullRefPtr.h>
LibWeb: Add definitions from '2.2.4. Bodies' in the Fetch spec ...at least the ones that don't require an implementation of the Streams spec :^)
2022-07-12 18:04:24 +01:00
#include <AK/Optional.h>
#include <AK/Variant.h>
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
#include <LibGC/Ptr.h>
#include <LibGC/Root.h>
LibWeb/Fetch: Implement Body's "fully read" function from the spec Required by XHR's reliance on Fetch.
2023-02-28 18:12:44 +00:00
#include <LibWeb/Fetch/Infrastructure/Task.h>
LibWeb: Add Blob to Fetch's Body::SourceType variant
2022-07-18 08:09:11 +01:00
#include <LibWeb/FileAPI/Blob.h>
LibWeb: Remove ReadableStreamDummy in favor of ReadableStream
2022-09-21 23:54:04 +01:00
#include <LibWeb/Streams/ReadableStream.h>
LibWeb: Clarify WebIDL::Promise as an alias for JS::PromiseCapability This patch adds the WebIDL::Promise type explicitly defined in the WebIDL spec to be a PromiseCapability Record from ecma262.
2023-02-13 11:58:39 +01:00
#include <LibWeb/WebIDL/Promise.h>
LibWeb: Add definitions from '2.2.4. Bodies' in the Fetch spec ...at least the ones that don't require an implementation of the Streams spec :^)
2022-07-12 18:04:24 +01:00
LibWeb: Move Fetch infra into the Web::Fetch::Infrastructure namespace The Fetch spec unfortunately will cause a name clash between the Request concept and the Request JS object - both cannot live in the Web::Fetch namespace, and WrapperGenerator generally assumes `Web::<Name>` for things living in the `<Name>/` subdirectory, so let's instead move infra code into its own namespace - it already sits in a (sub-)subdirectory anyway.
2022-07-17 23:52:02 +01:00
namespace Web::Fetch::Infrastructure {
LibWeb: Add definitions from '2.2.4. Bodies' in the Fetch spec ...at least the ones that don't require an implementation of the Streams spec :^)
2022-07-12 18:04:24 +01:00
// https://fetch.spec.whatwg.org/#concept-body
LibWeb: Make `Fetch::Infrastructure::Body` be GC allocated Making the body GC-allocated allows us to avoid using `JS::Handle` for `m_stream` in its members.
2023-08-18 19:38:13 +02:00
class Body final : public JS::Cell {
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC_CELL(Body, JS::Cell);
GC_DECLARE_ALLOCATOR(Body);
LibWeb: Make `Fetch::Infrastructure::Body` be GC allocated Making the body GC-allocated allows us to avoid using `JS::Handle` for `m_stream` in its members.
2023-08-18 19:38:13 +02:00
LibWeb: Add definitions from '2.2.4. Bodies' in the Fetch spec ...at least the ones that don't require an implementation of the Streams spec :^)
2022-07-12 18:04:24 +01:00
public:
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
using SourceType = Variant<Empty, ByteBuffer, GC::Root<FileAPI::Blob>>;
LibWeb: Make `processBodyError` take an optional exception Changed here: https://github.com/whatwg/fetch/commit/018ac19838ade92324a1900113636a8bf98f3a1b
2023-05-13 12:44:46 +01:00
// processBody must be an algorithm accepting a byte sequence.
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
using ProcessBodyCallback = GC::Ref<GC::Function<void(ByteBuffer)>>;
LibWeb: Make `processBodyError` take an optional exception Changed here: https://github.com/whatwg/fetch/commit/018ac19838ade92324a1900113636a8bf98f3a1b
2023-05-13 12:44:46 +01:00
// processBodyError must be an algorithm optionally accepting an exception.
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
using ProcessBodyErrorCallback = GC::Ref<GC::Function<void(JS::Value)>>;
LibWeb: Implement the concept incrementally read a body
2024-05-17 22:06:27 +02:00
// processBodyChunk must be an algorithm accepting a byte sequence.
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
using ProcessBodyChunkCallback = GC::Ref<GC::Function<void(ByteBuffer)>>;
LibWeb: Implement the concept incrementally read a body
2024-05-17 22:06:27 +02:00
// processEndOfBody must be an algorithm accepting no arguments
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
using ProcessEndOfBodyCallback = GC::Ref<GC::Function<void()>>;
LibWeb: Add definitions from '2.2.4. Bodies' in the Fetch spec ...at least the ones that don't require an implementation of the Streams spec :^)
2022-07-12 18:04:24 +01:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
[[nodiscard]] static GC::Ref<Body> create(JS::VM&, GC::Ref<Streams::ReadableStream>);
[[nodiscard]] static GC::Ref<Body> create(JS::VM&, GC::Ref<Streams::ReadableStream>, SourceType, Optional<u64>);
LibWeb: Add definitions from '2.2.4. Bodies' in the Fetch spec ...at least the ones that don't require an implementation of the Streams spec :^)
2022-07-12 18:04:24 +01:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
[[nodiscard]] GC::Ref<Streams::ReadableStream> stream() const { return *m_stream; }
void set_stream(GC::Ref<Streams::ReadableStream> value) { m_stream = value; }
LibWeb: Add definitions from '2.2.4. Bodies' in the Fetch spec ...at least the ones that don't require an implementation of the Streams spec :^)
2022-07-12 18:04:24 +01:00
[[nodiscard]] SourceType const& source() const { return m_source; }
[[nodiscard]] Optional<u64> const& length() const { return m_length; }
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
[[nodiscard]] GC::Ref<Body> clone(JS::Realm&);
LibWeb: Stub out Fetch::Infrastructure::Body::clone()
2022-09-25 19:25:53 +01:00
LibWeb: Add "parallel queue" and allow it as fetch task destination Note that it's not actually executing tasks in parallel, it's still throwing them on the HTML event loop task queue, each with its own unique task source. This makes our fetch implementation a lot more robust when HTTP caching is enabled, and you can now click links on https://terminal.shop/ without hitting TODO assertions in fetch.
2025-07-16 12:29:26 +02:00
void fully_read(JS::Realm&, ProcessBodyCallback process_body, ProcessBodyErrorCallback process_body_error, TaskDestination) const;
void incrementally_read(ProcessBodyChunkCallback process_body_chunk, ProcessEndOfBodyCallback process_end_of_body, ProcessBodyErrorCallback process_body_error, TaskDestination);
void incrementally_read_loop(Streams::ReadableStreamDefaultReader& reader, TaskDestination, ProcessBodyChunkCallback process_body_chunk, ProcessEndOfBodyCallback process_end_of_body, ProcessBodyErrorCallback process_body_error);
LibWeb: Stub out Fetch::Infrastructure::Body::fully_read_as_promise()
2022-09-25 19:27:02 +01:00
LibWeb: Make `Fetch::Infrastructure::Body` be GC allocated Making the body GC-allocated allows us to avoid using `JS::Handle` for `m_stream` in its members.
2023-08-18 19:38:13 +02:00
virtual void visit_edges(JS::Cell::Visitor&) override;
LibWeb: Add definitions from '2.2.4. Bodies' in the Fetch spec ...at least the ones that don't require an implementation of the Streams spec :^)
2022-07-12 18:04:24 +01:00
private:
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
explicit Body(GC::Ref<Streams::ReadableStream>);
Body(GC::Ref<Streams::ReadableStream>, SourceType, Optional<u64>);
LibWeb: Make `Fetch::Infrastructure::Body` be GC allocated Making the body GC-allocated allows us to avoid using `JS::Handle` for `m_stream` in its members.
2023-08-18 19:38:13 +02:00
LibWeb: Add definitions from '2.2.4. Bodies' in the Fetch spec ...at least the ones that don't require an implementation of the Streams spec :^)
2022-07-12 18:04:24 +01:00
// https://fetch.spec.whatwg.org/#concept-body-stream
// A stream (a ReadableStream object).
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ref<Streams::ReadableStream> m_stream;
LibWeb: Add definitions from '2.2.4. Bodies' in the Fetch spec ...at least the ones that don't require an implementation of the Streams spec :^)
2022-07-12 18:04:24 +01:00
// https://fetch.spec.whatwg.org/#concept-body-source
// A source (null, a byte sequence, a Blob object, or a FormData object), initially null.
SourceType m_source;
// https://fetch.spec.whatwg.org/#concept-body-total-bytes
// A length (null or an integer), initially null.
Optional<u64> m_length;
};
// https://fetch.spec.whatwg.org/#body-with-type
// A body with type is a tuple that consists of a body (a body) and a type (a header value or null).
struct BodyWithType {
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ref<Body> body;
LibWeb: Add definitions from '2.2.4. Bodies' in the Fetch spec ...at least the ones that don't require an implementation of the Streams spec :^)
2022-07-12 18:04:24 +01:00
Optional<ByteBuffer> type;
};
LibWeb: Remove exception handling from safely extracting response bodies The entire purpose of this AO is to avoid handling exceptions, which we can do now that the underlying AOs do not throw exceptions on OOM.
2024-11-04 16:06:01 +01:00
GC::Ref<Body> byte_sequence_as_body(JS::Realm&, ReadonlyBytes);
LibWeb: Implement 'Byte sequence as body' AO
2022-10-30 14:39:32 +00:00
LibWeb: Add definitions from '2.2.4. Bodies' in the Fetch spec ...at least the ones that don't require an implementation of the Streams spec :^)
2022-07-12 18:04:24 +01:00
}
Reference in a new issue Copy permalink