/* * Copyright (c) 2022-2023, Linus Groh * * SPDX-License-Identifier: BSD-2-Clause */ #include #include #include #include #include #include namespace Web::Fetch::Infrastructure { Body::Body(JS::Handle stream) : m_stream(move(stream)) { } Body::Body(JS::Handle stream, SourceType source, Optional length) : m_stream(move(stream)) , m_source(move(source)) , m_length(move(length)) { } // https://fetch.spec.whatwg.org/#concept-body-clone WebIDL::ExceptionOr Body::clone(JS::Realm& realm) const { // To clone a body body, run these steps: // 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(realm.heap().allocate(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/#body-fully-read WebIDL::ExceptionOr Body::fully_read(JS::Realm& realm, Web::Fetch::Infrastructure::Body::ProcessBodyCallback process_body, Web::Fetch::Infrastructure::Body::ProcessBodyErrorCallback process_body_error, TaskDestination task_destination) const { auto& vm = realm.vm(); // FIXME: 1. If taskDestination is null, then set taskDestination to the result of starting a new parallel queue. // FIXME: Handle 'parallel queue' task destination VERIFY(!task_destination.has()); auto task_destination_object = task_destination.get>(); // 2. Let successSteps given a byte sequence bytes be to queue a fetch task to run processBody given bytes, with taskDestination. auto success_steps = [process_body = move(process_body), task_destination_object = JS::make_handle(task_destination_object)](ByteBuffer const& bytes) mutable -> ErrorOr { // Make a copy of the bytes, as the source of the bytes may disappear between the time the task is queued and executed. auto bytes_copy = TRY(ByteBuffer::copy(bytes)); queue_fetch_task(*task_destination_object, [process_body = move(process_body), bytes_copy = move(bytes_copy)]() { process_body(move(bytes_copy)); }); return {}; }; // 3. Let errorSteps be to queue a fetch task to run processBodyError, with taskDestination. auto error_steps = [process_body_error = move(process_body_error), task_destination_object = JS::make_handle(task_destination_object)](JS::Error& error) mutable { queue_fetch_task(*task_destination_object, [process_body_error = move(process_body_error), error = JS::make_handle(error)]() { process_body_error(*error); }); }; // 4. Let reader be the result of getting a reader for body’s stream. If that threw an exception, then run errorSteps with that exception and return. // 5. Read all bytes from reader, given successSteps and errorSteps. // FIXME: Implement the streams spec - this is completely made up for now :^) if (auto const* byte_buffer = m_source.get_pointer()) { TRY_OR_THROW_OOM(vm, success_steps(*byte_buffer)); } else { // Empty, Blob, FormData error_steps(TRY(JS::InternalError::create(realm, "Reading from Blob, FormData or null source is not yet implemented"sv))); } return {}; } // https://fetch.spec.whatwg.org/#byte-sequence-as-a-body WebIDL::ExceptionOr 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; } }