ladybird/Userland/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Bodies.cpp

/*
 * Copyright (c) 2022, Linus Groh <linusg@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <LibJS/Runtime/PromiseCapability.h>
#include <LibWeb/Bindings/MainThreadVM.h>
#include <LibWeb/Fetch/BodyInit.h>
#include <LibWeb/Fetch/Infrastructure/HTTP/Bodies.h>
#include <LibWeb/WebIDL/Promise.h>

namespace Web::Fetch::Infrastructure {

Body::Body(JS::Handle<Streams::ReadableStream> stream)
    : m_stream(move(stream))
{
}

Body::Body(JS::Handle<Streams::ReadableStream> stream, SourceType source, Optional<u64> length)
    : m_stream(move(stream))
    , m_source(move(source))
    , m_length(move(length))
{
}

// https://fetch.spec.whatwg.org/#concept-body-clone
WebIDL::ExceptionOr<Body> Body::clone() const
{
    // To clone a body body, run these steps:

    auto& vm = Bindings::main_thread_vm();
    auto& realm = *vm.current_realm();

    // FIXME: 1. Let « out1, out2 » be the result of teeing body’s stream.
    // FIXME: 2. Set body’s stream to out1.
    auto out2 = MUST_OR_THROW_OOM(vm.heap().allocate<Streams::ReadableStream>(realm, realm));

    // 3. Return a body whose stream is out2 and other members are copied from body.
    return Body { JS::make_handle(out2), m_source, m_length };
}

// https://fetch.spec.whatwg.org/#fully-reading-body-as-promise
JS::NonnullGCPtr<WebIDL::Promise> Body::fully_read_as_promise() const
{
    auto& vm = Bindings::main_thread_vm();
    auto& realm = *vm.current_realm();

    // FIXME: Implement the streams spec - this is completely made up for now :^)
    if (auto const* byte_buffer = m_source.get_pointer<ByteBuffer>()) {
        auto result = DeprecatedString::copy(*byte_buffer);
        return WebIDL::create_resolved_promise(realm, JS::PrimitiveString::create(vm, move(result)));
    }
    // Empty, Blob, FormData
    return WebIDL::create_rejected_promise(realm, JS::InternalError::create(realm, "Reading body isn't fully implemented"sv).release_allocated_value_but_fixme_should_propagate_errors());
}

// https://fetch.spec.whatwg.org/#byte-sequence-as-a-body
WebIDL::ExceptionOr<Body> byte_sequence_as_body(JS::Realm& realm, ReadonlyBytes bytes)
{
    // To get a byte sequence bytes as a body, return the body of the result of safely extracting bytes.
    auto [body, _] = TRY(safely_extract_body(realm, bytes));
    return 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
+								/*
 								 * Copyright (c) 2022, Linus Groh <linusg@serenityos.org>
 								 *
 								 * SPDX-License-Identifier: BSD-2-Clause
 								 */
-												LibJS: Move PromiseCapability into its own cpp/h file

This is not strictly connected to PromiseReaction in any way.
Preparation before doing some actual work on it :^)

											
										
										
											2022-10-02 10:59:22 +01:00
+								#include <LibJS/Runtime/PromiseCapability.h>
-												LibWeb: Stub out Fetch::Infrastructure::Body::clone()

											
										
										
											2022-09-25 19:25:53 +01:00
+								#include <LibWeb/Bindings/MainThreadVM.h>
-												LibWeb: Implement 'Byte sequence as body' AO

											
										
										
											2022-10-30 14:39:32 +00:00
+								#include <LibWeb/Fetch/BodyInit.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 <LibWeb/Fetch/Infrastructure/HTTP/Bodies.h>
-												LibWeb: Stub out Fetch::Infrastructure::Body::fully_read_as_promise()

											
										
										
											2022-09-25 19:27:02 +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
-												LibWeb: Remove ReadableStreamDummy in favor of ReadableStream

											
										
										
											2022-09-21 23:54:04 +01:00
+								Body::Body(JS::Handle<Streams::ReadableStream> stream)
 								    : m_stream(move(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
+								{
 								}
-												LibWeb: Remove ReadableStreamDummy in favor of ReadableStream

											
										
										
											2022-09-21 23:54:04 +01:00
+								Body::Body(JS::Handle<Streams::ReadableStream> stream, SourceType source, Optional<u64> length)
 								    : m_stream(move(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
+								    , m_source(move(source))
 								    , m_length(move(length))
 								{
 								}
-												LibWeb: Stub out Fetch::Infrastructure::Body::clone()

											
										
										
											2022-09-25 19:25:53 +01:00
+								// https://fetch.spec.whatwg.org/#concept-body-clone
 								WebIDL::ExceptionOr<Body> Body::clone() const
 								{
 								    // To clone a body body, run these steps:
 								    auto& vm = Bindings::main_thread_vm();
 								    auto& realm = *vm.current_realm();
 								    // FIXME: 1. Let « out1, out2 » be the result of teeing body’s stream.
 								    // FIXME: 2. Set body’s stream to out1.
-												LibJS+Everywhere: Propagate Cell::initialize errors from Heap::allocate

Callers that are already in a fallible context will now TRY to allocate
cells. Callers in infallible contexts get a FIXME.

											
										
										
											2023-01-28 13:39:44 -05:00
+								    auto out2 = MUST_OR_THROW_OOM(vm.heap().allocate<Streams::ReadableStream>(realm, realm));
-												LibWeb: Stub out Fetch::Infrastructure::Body::clone()

											
										
										
											2022-09-25 19:25:53 +01:00
 								    // 3. Return a body whose stream is out2 and other members are copied from body.
 								    return Body { JS::make_handle(out2), m_source, m_length };
 								}
-												LibWeb: Stub out Fetch::Infrastructure::Body::fully_read_as_promise()

											
										
										
											2022-09-25 19:27:02 +01:00
+								// https://fetch.spec.whatwg.org/#fully-reading-body-as-promise
-												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
+								JS::NonnullGCPtr<WebIDL::Promise> Body::fully_read_as_promise() const
-												LibWeb: Stub out Fetch::Infrastructure::Body::fully_read_as_promise()

											
										
										
											2022-09-25 19:27:02 +01:00
+								{
 								    auto& vm = Bindings::main_thread_vm();
 								    auto& realm = *vm.current_realm();
 								    // FIXME: Implement the streams spec - this is completely made up for now :^)
 								    if (auto const* byte_buffer = m_source.get_pointer<ByteBuffer>()) {
-												AK+Everywhere: Rename String to DeprecatedString

We have a new, improved string type coming up in AK (OOM aware, no null
state), and while it's going to use UTF-8, the name UTF8String is a
mouthful - so let's free up the String name by renaming the existing
class.
Making the old one have an annoying name will hopefully also help with
quick adoption :^)

											
										
										
											2022-12-04 18:02:33 +00:00
+								        auto result = DeprecatedString::copy(*byte_buffer);
-												LibJS: Replace standalone js_string() with PrimitiveString::create()

Note that js_rope_string() has been folded into this, the old name was
misleading - it would not always create a rope string, only if both
sides are not empty strings. Use a three-argument create() overload
instead.

											
										
										
											2022-12-06 22:17:27 +00:00
+								        return WebIDL::create_resolved_promise(realm, JS::PrimitiveString::create(vm, move(result)));
-												LibWeb: Stub out Fetch::Infrastructure::Body::fully_read_as_promise()

											
										
										
											2022-09-25 19:27:02 +01:00
+								    }
 								    // Empty, Blob, FormData
-												LibJS+Everywhere: Convert JS::Error to String

This includes an Error::create overload to create an Error from a UTF-8
StringView. If creating a String from that view fails, the factory will
return an OOM InternalError instead. VM::throw_completion can also make
use of this overload via its perfect forwarding.

											
										
										
											2023-02-16 14:09:11 -05:00
+								    return WebIDL::create_rejected_promise(realm, JS::InternalError::create(realm, "Reading body isn't fully implemented"sv).release_allocated_value_but_fixme_should_propagate_errors());
-												LibWeb: Stub out Fetch::Infrastructure::Body::fully_read_as_promise()

											
										
										
											2022-09-25 19:27:02 +01:00
+								}
-												LibWeb: Implement 'Byte sequence as body' AO

											
										
										
											2022-10-30 14:39:32 +00:00
+								// https://fetch.spec.whatwg.org/#byte-sequence-as-a-body
 								WebIDL::ExceptionOr<Body> byte_sequence_as_body(JS::Realm& realm, ReadonlyBytes bytes)
 								{
 								    // To get a byte sequence bytes as a body, return the body of the result of safely extracting bytes.
 								    auto [body, _] = TRY(safely_extract_body(realm, bytes));
 								    return 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
+								}