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

256 lines
12 KiB
C
Raw Normal View History

LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
/*
* Copyright (c) 2022, Linus Groh <linusg@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/ByteBuffer.h>
#include <AK/Error.h>
#include <AK/Forward.h>
#include <AK/Optional.h>
#include <AK/URL.h>
#include <AK/Vector.h>
#include <LibWeb/Fetch/Infrastructure/HTTP/Bodies.h>
#include <LibWeb/Fetch/Infrastructure/HTTP/Headers.h>
#include <LibWeb/Fetch/Infrastructure/HTTP/Statuses.h>
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.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
// https://fetch.spec.whatwg.org/#concept-response
class Response {
public:
enum class CacheState {
Local,
Validated,
};
enum class Type {
Basic,
CORS,
Default,
Error,
Opaque,
OpaqueRedirect,
};
// https://fetch.spec.whatwg.org/#response-body-info
struct BodyInfo {
// https://fetch.spec.whatwg.org/#fetch-timing-info-encoded-body-size
u64 encoded_size { 0 };
// https://fetch.spec.whatwg.org/#fetch-timing-info-decoded-body-size
u64 decoded_size { 0 };
};
LibWeb: Heap-allocate returned Fetch::Infrastructure::{Request,Response} A Request/Response instance should always be heap-allocated and have clear ownership, so let's also wrap it in a NonnullOwnPtr instead of putting them on the stack.
2022-09-24 00:28:11 +01:00
[[nodiscard]] static NonnullOwnPtr<Response> aborted_network_error();
[[nodiscard]] static NonnullOwnPtr<Response> network_error();
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
LibWeb: Make HeaderList ref-counted This is needed to eventually share a header list between a Request or Response object's internal infra request/response and the object's exposed Header object.
2022-09-25 20:52:51 +01:00
Response();
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
virtual ~Response() = default;
[[nodiscard]] virtual Type type() const { return m_type; }
void set_type(Type type) { m_type = type; }
[[nodiscard]] virtual bool aborted() const { return m_aborted; }
void set_aborted(bool aborted) { m_aborted = aborted; }
[[nodiscard]] virtual Vector<AK::URL> const& url_list() const { return m_url_list; }
[[nodiscard]] Vector<AK::URL>& url_list() { return m_url_list; }
void set_url_list(Vector<AK::URL> url_list) { m_url_list = move(url_list); }
[[nodiscard]] virtual Status status() const { return m_status; }
void set_status(Status status) { m_status = status; }
[[nodiscard]] virtual ReadonlyBytes status_message() const { return m_status_message; }
void set_status_message(ByteBuffer status_message) { m_status_message = move(status_message); }
LibWeb: Make HeaderList ref-counted This is needed to eventually share a header list between a Request or Response object's internal infra request/response and the object's exposed Header object.
2022-09-25 20:52:51 +01:00
[[nodiscard]] virtual NonnullRefPtr<HeaderList> const& header_list() const { return m_header_list; }
[[nodiscard]] NonnullRefPtr<HeaderList>& header_list() { return m_header_list; }
void set_header_list(NonnullRefPtr<HeaderList> header_list) { m_header_list = move(header_list); }
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
[[nodiscard]] virtual Optional<Body> const& body() const { return m_body; }
[[nodiscard]] Optional<Body>& body() { return m_body; }
void set_body(Optional<Body> body) { m_body = move(body); }
[[nodiscard]] virtual Optional<CacheState> const& cache_state() const { return m_cache_state; }
void set_cache_state(Optional<CacheState> cache_state) { m_cache_state = move(cache_state); }
[[nodiscard]] virtual Vector<ByteBuffer> const& cors_exposed_header_name_list() const { return m_cors_exposed_header_name_list; }
[[nodiscard]] Vector<ByteBuffer>& cors_exposed_header_name_list() { return m_cors_exposed_header_name_list; }
void set_cors_exposed_header_name_list(Vector<ByteBuffer> cors_exposed_header_name_list) { m_cors_exposed_header_name_list = move(cors_exposed_header_name_list); }
[[nodiscard]] virtual bool range_requested() const { return m_range_requested; }
void set_range_requested(bool range_requested) { m_range_requested = range_requested; }
[[nodiscard]] virtual bool request_includes_credentials() const { return m_request_includes_credentials; }
void set_request_includes_credentials(bool request_includes_credentials) { m_request_includes_credentials = request_includes_credentials; }
[[nodiscard]] virtual bool timing_allow_passed() const { return m_timing_allow_passed; }
void set_timing_allow_passed(bool timing_allow_passed) { m_timing_allow_passed = timing_allow_passed; }
[[nodiscard]] virtual BodyInfo const& body_info() const { return m_body_info; }
[[nodiscard]] BodyInfo& body_info() { return m_body_info; }
void set_body_info(BodyInfo body_info) { m_body_info = body_info; }
[[nodiscard]] bool is_aborted_network_error() const;
[[nodiscard]] bool is_network_error() const;
[[nodiscard]] Optional<AK::URL const&> url() const;
[[nodiscard]] ErrorOr<Optional<AK::URL>> location_url(Optional<String> const& request_fragment) const;
LibWeb: Stub out Fetch::Infrastructure::Body::clone()
2022-09-25 19:25:53 +01:00
[[nodiscard]] WebIDL::ExceptionOr<NonnullOwnPtr<Response>> clone() const;
LibWeb: Implement Fetch::Infrastructure::Response::clone()
2022-09-25 19:23:35 +01:00
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
private:
// https://fetch.spec.whatwg.org/#concept-response-type
// A response has an associated type which is "basic", "cors", "default", "error", "opaque", or "opaqueredirect". Unless stated otherwise, it is "default".
Type m_type { Type::Default };
// https://fetch.spec.whatwg.org/#concept-response-aborted
// A response can have an associated aborted flag, which is initially unset.
bool m_aborted { false };
// A response has an associated URL list (a list of zero or more URLs). Unless stated otherwise, it is the empty list.
Vector<AK::URL> m_url_list;
// https://fetch.spec.whatwg.org/#concept-response-status
// A response has an associated status, which is a status. Unless stated otherwise it is 200.
Status m_status { 200 };
// https://fetch.spec.whatwg.org/#concept-response-status-message
// A response has an associated status message. Unless stated otherwise it is the empty byte sequence.
ByteBuffer m_status_message;
// https://fetch.spec.whatwg.org/#concept-response-header-list
// A response has an associated header list (a header list). Unless stated otherwise it is empty.
LibWeb: Make HeaderList ref-counted This is needed to eventually share a header list between a Request or Response object's internal infra request/response and the object's exposed Header object.
2022-09-25 20:52:51 +01:00
NonnullRefPtr<HeaderList> m_header_list;
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
// https://fetch.spec.whatwg.org/#concept-response-body
// A response has an associated body (null or a body). Unless stated otherwise it is null.
Optional<Body> m_body;
// https://fetch.spec.whatwg.org/#concept-response-cache-state
// A response has an associated cache state (the empty string, "local", or "validated"). Unless stated otherwise, it is the empty string.
Optional<CacheState> m_cache_state;
// https://fetch.spec.whatwg.org/#concept-response-cors-exposed-header-name-list
// A response has an associated CORS-exposed header-name list (a list of zero or more header names). The list is empty unless otherwise specified.
Vector<ByteBuffer> m_cors_exposed_header_name_list;
// https://fetch.spec.whatwg.org/#concept-response-range-requested-flag
// A response has an associated range-requested flag, which is initially unset.
bool m_range_requested { false };
// https://fetch.spec.whatwg.org/#response-request-includes-credentials
// A response has an associated request-includes-credentials (a boolean), which is initially true.
bool m_request_includes_credentials { true };
// https://fetch.spec.whatwg.org/#concept-response-timing-allow-passed
// A response has an associated timing allow passed flag, which is initially unset.
bool m_timing_allow_passed { false };
// https://fetch.spec.whatwg.org/#concept-response-body-info
// A response has an associated body info (a response body info). Unless stated otherwise, it is a new response body info.
BodyInfo m_body_info;
// https://fetch.spec.whatwg.org/#response-service-worker-timing-info
// FIXME: A response has an associated service worker timing info (null or a service worker timing info), which is initially null.
};
// https://fetch.spec.whatwg.org/#concept-filtered-response
LibWeb: Heap-allocate returned Fetch::Infrastructure::{Request,Response} A Request/Response instance should always be heap-allocated and have clear ownership, so let's also wrap it in a NonnullOwnPtr instead of putting them on the stack.
2022-09-24 00:28:11 +01:00
class FilteredResponse : public Response {
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
public:
explicit FilteredResponse(Response&);
virtual ~FilteredResponse() = 0;
[[nodiscard]] virtual Type type() const override { return m_internal_response.type(); }
[[nodiscard]] virtual bool aborted() const override { return m_internal_response.aborted(); }
[[nodiscard]] virtual Vector<AK::URL> const& url_list() const override { return m_internal_response.url_list(); }
[[nodiscard]] virtual Status status() const override { return m_internal_response.status(); }
[[nodiscard]] virtual ReadonlyBytes status_message() const override { return m_internal_response.status_message(); }
LibWeb: Make HeaderList ref-counted This is needed to eventually share a header list between a Request or Response object's internal infra request/response and the object's exposed Header object.
2022-09-25 20:52:51 +01:00
[[nodiscard]] virtual NonnullRefPtr<HeaderList> const& header_list() const override { return m_internal_response.header_list(); }
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
[[nodiscard]] virtual Optional<Body> const& body() const override { return m_internal_response.body(); }
[[nodiscard]] virtual Optional<CacheState> const& cache_state() const override { return m_internal_response.cache_state(); }
[[nodiscard]] virtual Vector<ByteBuffer> const& cors_exposed_header_name_list() const override { return m_internal_response.cors_exposed_header_name_list(); }
[[nodiscard]] virtual bool range_requested() const override { return m_internal_response.range_requested(); }
[[nodiscard]] virtual bool request_includes_credentials() const override { return m_internal_response.request_includes_credentials(); }
[[nodiscard]] virtual bool timing_allow_passed() const override { return m_internal_response.timing_allow_passed(); }
[[nodiscard]] virtual BodyInfo const& body_info() const override { return m_internal_response.body_info(); }
[[nodiscard]] Response const& internal_response() const { return m_internal_response; }
[[nodiscard]] Response& internal_response() { return m_internal_response; }
protected:
// https://fetch.spec.whatwg.org/#concept-internal-response
Response& m_internal_response;
};
// https://fetch.spec.whatwg.org/#concept-filtered-response-basic
class BasicFilteredResponse final : public FilteredResponse {
public:
LibWeb: Heap-allocate returned Fetch::Infrastructure::{Request,Response} A Request/Response instance should always be heap-allocated and have clear ownership, so let's also wrap it in a NonnullOwnPtr instead of putting them on the stack.
2022-09-24 00:28:11 +01:00
static ErrorOr<NonnullOwnPtr<BasicFilteredResponse>> create(Response&);
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
[[nodiscard]] virtual Type type() const override { return Type::Basic; }
LibWeb: Make HeaderList ref-counted This is needed to eventually share a header list between a Request or Response object's internal infra request/response and the object's exposed Header object.
2022-09-25 20:52:51 +01:00
[[nodiscard]] virtual NonnullRefPtr<HeaderList> const& header_list() const override { return m_header_list; }
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
private:
LibWeb: Make HeaderList ref-counted This is needed to eventually share a header list between a Request or Response object's internal infra request/response and the object's exposed Header object.
2022-09-25 20:52:51 +01:00
BasicFilteredResponse(Response&, NonnullRefPtr<HeaderList>);
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
LibWeb: Make HeaderList ref-counted This is needed to eventually share a header list between a Request or Response object's internal infra request/response and the object's exposed Header object.
2022-09-25 20:52:51 +01:00
NonnullRefPtr<HeaderList> m_header_list;
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
};
// https://fetch.spec.whatwg.org/#concept-filtered-response-cors
class CORSFilteredResponse final : public FilteredResponse {
public:
LibWeb: Heap-allocate returned Fetch::Infrastructure::{Request,Response} A Request/Response instance should always be heap-allocated and have clear ownership, so let's also wrap it in a NonnullOwnPtr instead of putting them on the stack.
2022-09-24 00:28:11 +01:00
static ErrorOr<NonnullOwnPtr<CORSFilteredResponse>> create(Response&);
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
[[nodiscard]] virtual Type type() const override { return Type::CORS; }
LibWeb: Make HeaderList ref-counted This is needed to eventually share a header list between a Request or Response object's internal infra request/response and the object's exposed Header object.
2022-09-25 20:52:51 +01:00
[[nodiscard]] virtual NonnullRefPtr<HeaderList> const& header_list() const override { return m_header_list; }
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
private:
LibWeb: Make HeaderList ref-counted This is needed to eventually share a header list between a Request or Response object's internal infra request/response and the object's exposed Header object.
2022-09-25 20:52:51 +01:00
CORSFilteredResponse(Response&, NonnullRefPtr<HeaderList>);
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
LibWeb: Make HeaderList ref-counted This is needed to eventually share a header list between a Request or Response object's internal infra request/response and the object's exposed Header object.
2022-09-25 20:52:51 +01:00
NonnullRefPtr<HeaderList> m_header_list;
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
};
// https://fetch.spec.whatwg.org/#concept-filtered-response-opaque
class OpaqueFilteredResponse final : public FilteredResponse {
public:
LibWeb: Heap-allocate returned Fetch::Infrastructure::{Request,Response} A Request/Response instance should always be heap-allocated and have clear ownership, so let's also wrap it in a NonnullOwnPtr instead of putting them on the stack.
2022-09-24 00:28:11 +01:00
static NonnullOwnPtr<OpaqueFilteredResponse> create(Response&);
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
[[nodiscard]] virtual Type type() const override { return Type::Opaque; }
[[nodiscard]] virtual Vector<AK::URL> const& url_list() const override { return m_url_list; }
[[nodiscard]] virtual Status status() const override { return 0; }
[[nodiscard]] virtual ReadonlyBytes status_message() const override { return {}; }
LibWeb: Make HeaderList ref-counted This is needed to eventually share a header list between a Request or Response object's internal infra request/response and the object's exposed Header object.
2022-09-25 20:52:51 +01:00
[[nodiscard]] virtual NonnullRefPtr<HeaderList> const& header_list() const override { return m_header_list; }
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
[[nodiscard]] virtual Optional<Body> const& body() const override { return m_body; }
private:
explicit OpaqueFilteredResponse(Response&);
Vector<AK::URL> m_url_list;
LibWeb: Make HeaderList ref-counted This is needed to eventually share a header list between a Request or Response object's internal infra request/response and the object's exposed Header object.
2022-09-25 20:52:51 +01:00
NonnullRefPtr<HeaderList> m_header_list;
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
Optional<Body> m_body;
};
// https://fetch.spec.whatwg.org/#concept-filtered-response-opaque-redirect
class OpaqueRedirectFilteredResponse final : public FilteredResponse {
public:
LibWeb: Heap-allocate returned Fetch::Infrastructure::{Request,Response} A Request/Response instance should always be heap-allocated and have clear ownership, so let's also wrap it in a NonnullOwnPtr instead of putting them on the stack.
2022-09-24 00:28:11 +01:00
static NonnullOwnPtr<OpaqueRedirectFilteredResponse> create(Response&);
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
[[nodiscard]] virtual Type type() const override { return Type::OpaqueRedirect; }
[[nodiscard]] virtual Status status() const override { return 0; }
[[nodiscard]] virtual ReadonlyBytes status_message() const override { return {}; }
LibWeb: Make HeaderList ref-counted This is needed to eventually share a header list between a Request or Response object's internal infra request/response and the object's exposed Header object.
2022-09-25 20:52:51 +01:00
[[nodiscard]] virtual NonnullRefPtr<HeaderList> const& header_list() const override { return m_header_list; }
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
[[nodiscard]] virtual Optional<Body> const& body() const override { return m_body; }
private:
explicit OpaqueRedirectFilteredResponse(Response&);
LibWeb: Make HeaderList ref-counted This is needed to eventually share a header list between a Request or Response object's internal infra request/response and the object's exposed Header object.
2022-09-25 20:52:51 +01:00
NonnullRefPtr<HeaderList> m_header_list;
LibWeb: Add definitions from '2.2.6. Responses' in the Fetch spec
2022-07-16 17:55:29 +01:00
Optional<Body> m_body;
};
}
Reference in a new issue Copy permalink