Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-31 13:20:59 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Requests.h

521 lines
22 KiB
C
Raw Normal View History

LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +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/Fetch: Implement changes to priority This patch updates the priority member of fetch requests to be an enum. The implementation defined struct previously named Priority has been renamed to InternalPriority in line with the spec.
2023-10-29 02:49:22 +01:00
* Copyright (c) 2023, networkException <networkexception@serenityos.org>
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/ByteBuffer.h>
#include <AK/Error.h>
#include <AK/Forward.h>
#include <AK/Optional.h>
LibWeb/Fetch: Port infrastructure to new String
2023-03-02 23:26:35 +00:00
#include <AK/String.h>
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
#include <AK/Variant.h>
#include <AK/Vector.h>
LibWeb: Make Fetch::Infrastructure::{Request,Response,HeaderList} GC'd This is the way. On a more serious note, there's no reason to keep adding ref-counted classes to LibWeb now that the majority of classes is GC'd - it only adds the risk of discovering some cycle down the line, and forces us to use handles as we can't visit().
2022-10-30 01:52:07 +00:00
#include <LibJS/Forward.h>
#include <LibJS/Heap/Cell.h>
LibWeb: Add missing GCPtr.h includes to Fetch headers These are missing in most Fetch headers, and clangd is (rightfully) very loud about it on a few of these.
2023-02-10 08:29:14 -05:00
#include <LibJS/Heap/GCPtr.h>
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 16:22:27 +13:00
#include <LibURL/URL.h>
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
#include <LibWeb/Fetch/Infrastructure/HTTP/Bodies.h>
#include <LibWeb/Fetch/Infrastructure/HTTP/Headers.h>
#include <LibWeb/HTML/Origin.h>
#include <LibWeb/HTML/PolicyContainers.h>
#include <LibWeb/HTML/Scripting/Environments.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.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// https://fetch.spec.whatwg.org/#concept-request
LibWeb: Make Fetch::Infrastructure::{Request,Response,HeaderList} GC'd This is the way. On a more serious note, there's no reason to keep adding ref-counted classes to LibWeb now that the majority of classes is GC'd - it only adds the risk of discovering some cycle down the line, and forces us to use handles as we can't visit().
2022-10-30 01:52:07 +00:00
class Request final : public JS::Cell {
JS_CELL(Request, JS::Cell);
LibWeb: Put most LibWeb GC objects in type-specific heap blocks With this change, we now have ~1200 CellAllocators across both LibJS and LibWeb in a normal WebContent instance. This gives us a minimum heap size of 4.7 MiB in the scenario where we only have one cell allocated per type. Of course, in practice there will be many more of each type, so the effective overhead is quite a bit smaller than that in practice. I left a few types unconverted to this mechanism because I got tired of doing this. :^)
2023-11-19 19:47:52 +01:00
JS_DECLARE_ALLOCATOR(Request);
LibWeb: Make Fetch::Infrastructure::{Request,Response,HeaderList} GC'd This is the way. On a more serious note, there's no reason to keep adding ref-counted classes to LibWeb now that the majority of classes is GC'd - it only adds the risk of discovering some cycle down the line, and forces us to use handles as we can't visit().
2022-10-30 01:52:07 +00:00
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
public:
enum class CacheMode {
Default,
NoStore,
Reload,
NoCache,
ForceCache,
OnlyIfCached,
};
enum class CredentialsMode {
Omit,
SameOrigin,
Include,
};
enum class Destination {
Audio,
AudioWorklet,
Document,
Embed,
Font,
Frame,
IFrame,
Image,
LibWeb/Fetch: Add "json" destination for JSON modules This is a change in the Fetch spec. See: - https://github.com/whatwg/fetch/commit/49bff76
2024-04-29 20:11:02 +01:00
JSON,
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
Manifest,
Object,
PaintWorklet,
Report,
Script,
ServiceWorker,
SharedWorker,
Style,
Track,
Video,
LibWeb/Fetch: Add "webidentity" destination for FedCM This is a change in the Fetch spec. See: - https://github.com/whatwg/fetch/commit/30d462d - https://github.com/whatwg/fetch/commit/7487a97
2022-10-15 00:42:52 +02:00
WebIdentity,
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
Worker,
XSLT,
};
enum class Initiator {
Download,
ImageSet,
Manifest,
Prefetch,
Prerender,
XSLT,
};
enum class InitiatorType {
Audio,
Beacon,
Body,
CSS,
EarlyHint,
Embed,
Fetch,
Font,
Frame,
IFrame,
Image,
IMG,
Input,
Link,
Object,
Ping,
Script,
Track,
Video,
XMLHttpRequest,
Other,
};
enum class Mode {
SameOrigin,
CORS,
NoCORS,
Navigate,
WebSocket,
};
enum class Origin {
Client,
};
enum class ParserMetadata {
ParserInserted,
NotParserInserted,
};
enum class PolicyContainer {
Client,
};
enum class RedirectMode {
Follow,
Error,
Manual,
};
enum class Referrer {
NoReferrer,
Client,
};
enum class ResponseTainting {
Basic,
CORS,
Opaque,
};
enum class ServiceWorkersMode {
All,
None,
};
enum class Window {
NoWindow,
Client,
};
LibWeb/Fetch: Implement changes to priority This patch updates the priority member of fetch requests to be an enum. The implementation defined struct previously named Priority has been renamed to InternalPriority in line with the spec.
2023-10-29 02:49:22 +01:00
enum class Priority {
High,
Low,
Auto
};
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// Members are implementation-defined
LibWeb/Fetch: Implement changes to priority This patch updates the priority member of fetch requests to be an enum. The implementation defined struct previously named Priority has been renamed to InternalPriority in line with the spec.
2023-10-29 02:49:22 +01:00
struct InternalPriority { };
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +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
using BodyType = Variant<Empty, ByteBuffer, JS::NonnullGCPtr<Body>>;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
using OriginType = Variant<Origin, HTML::Origin>;
using PolicyContainerType = Variant<PolicyContainer, HTML::PolicyContainer>;
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 16:22:27 +13:00
using ReferrerType = Variant<Referrer, URL::URL>;
LibWeb: Make HTML::Environment a GC-allocated type The only subclass was already GC-allocated, so let's hoist the JS::Cell inheritance up one level. This ends up simplifying a bit of rather dubious looking code where we were previously slicing ESOs.
2024-04-24 11:09:36 +02:00
using ReservedClientType = JS::GCPtr<HTML::Environment>;
LibJS+LibWeb: Wrap raw JS::Cell*/& fields in GCPtr/NonnullGCPtr
2023-02-26 16:09:02 -07:00
using WindowType = Variant<Window, JS::GCPtr<HTML::EnvironmentSettingsObject>>;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
LibWeb: Make Fetch::Infrastructure::{Request,Response,HeaderList} GC'd This is the way. On a more serious note, there's no reason to keep adding ref-counted classes to LibWeb now that the majority of classes is GC'd - it only adds the risk of discovering some cycle down the line, and forces us to use handles as we can't visit().
2022-10-30 01:52:07 +00:00
[[nodiscard]] static JS::NonnullGCPtr<Request> create(JS::VM&);
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
LibWeb: Mark two Fetch::Infrastructure::Request getters as const
2022-09-24 00:23:55 +01:00
[[nodiscard]] ReadonlyBytes method() const { return m_method; }
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
void set_method(ByteBuffer method) { m_method = move(method); }
[[nodiscard]] bool local_urls_only() const { return m_local_urls_only; }
void set_local_urls_only(bool local_urls_only) { m_local_urls_only = local_urls_only; }
LibWeb: Make Fetch::Infrastructure::{Request,Response,HeaderList} GC'd This is the way. On a more serious note, there's no reason to keep adding ref-counted classes to LibWeb now that the majority of classes is GC'd - it only adds the risk of discovering some cycle down the line, and forces us to use handles as we can't visit().
2022-10-30 01:52:07 +00:00
[[nodiscard]] JS::NonnullGCPtr<HeaderList> header_list() const { return m_header_list; }
void set_header_list(JS::NonnullGCPtr<HeaderList> header_list) { m_header_list = header_list; }
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
[[nodiscard]] bool unsafe_request() const { return m_unsafe_request; }
void set_unsafe_request(bool unsafe_request) { m_unsafe_request = unsafe_request; }
[[nodiscard]] BodyType const& body() const { return m_body; }
[[nodiscard]] BodyType& body() { return m_body; }
void set_body(BodyType body) { m_body = move(body); }
LibJS+LibWeb: Wrap raw JS::Cell*/& fields in GCPtr/NonnullGCPtr
2023-02-26 16:09:02 -07:00
[[nodiscard]] JS::GCPtr<HTML::EnvironmentSettingsObject const> client() const { return m_client; }
[[nodiscard]] JS::GCPtr<HTML::EnvironmentSettingsObject> client() { return m_client; }
LibWeb: Make Fetch::Infrastructure::Request::set_client() take a pointer
2022-10-04 23:43:37 +01:00
void set_client(HTML::EnvironmentSettingsObject* client) { m_client = client; }
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
[[nodiscard]] ReservedClientType const& reserved_client() const { return m_reserved_client; }
[[nodiscard]] ReservedClientType& reserved_client() { return m_reserved_client; }
void set_reserved_client(ReservedClientType reserved_client) { m_reserved_client = move(reserved_client); }
LibWeb/Fetch: Port infrastructure to new String
2023-03-02 23:26:35 +00:00
[[nodiscard]] String const& replaces_client_id() const { return m_replaces_client_id; }
void set_replaces_client_id(String replaces_client_id) { m_replaces_client_id = move(replaces_client_id); }
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
[[nodiscard]] WindowType const& window() const { return m_window; }
void set_window(WindowType window) { m_window = move(window); }
[[nodiscard]] bool keepalive() const { return m_keepalive; }
void set_keepalive(bool keepalive) { m_keepalive = keepalive; }
[[nodiscard]] Optional<InitiatorType> const& initiator_type() const { return m_initiator_type; }
void set_initiator_type(Optional<InitiatorType> initiator_type) { m_initiator_type = move(initiator_type); }
LibWeb: Mark two Fetch::Infrastructure::Request getters as const
2022-09-24 00:23:55 +01:00
[[nodiscard]] ServiceWorkersMode service_workers_mode() const { return m_service_workers_mode; }
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
void set_service_workers_mode(ServiceWorkersMode service_workers_mode) { m_service_workers_mode = service_workers_mode; }
[[nodiscard]] Optional<Initiator> const& initiator() const { return m_initiator; }
void set_initiator(Optional<Initiator> initiator) { m_initiator = move(initiator); }
[[nodiscard]] Optional<Destination> const& destination() const { return m_destination; }
void set_destination(Optional<Destination> destination) { m_destination = move(destination); }
LibWeb/Fetch: Implement changes to priority This patch updates the priority member of fetch requests to be an enum. The implementation defined struct previously named Priority has been renamed to InternalPriority in line with the spec.
2023-10-29 02:49:22 +01:00
[[nodiscard]] Priority const& priority() const { return m_priority; }
void set_priority(Priority priority) { m_priority = priority; }
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
[[nodiscard]] OriginType const& origin() const { return m_origin; }
void set_origin(OriginType origin) { m_origin = move(origin); }
LibWeb: Add missing Request::policy_container() getter and setter
2022-10-04 23:45:28 +01:00
[[nodiscard]] PolicyContainerType const& policy_container() const { return m_policy_container; }
void set_policy_container(PolicyContainerType policy_container) { m_policy_container = move(policy_container); }
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
[[nodiscard]] Mode mode() const { return m_mode; }
void set_mode(Mode mode) { m_mode = mode; }
[[nodiscard]] bool use_cors_preflight() const { return m_use_cors_preflight; }
void set_use_cors_preflight(bool use_cors_preflight) { m_use_cors_preflight = use_cors_preflight; }
[[nodiscard]] CredentialsMode credentials_mode() const { return m_credentials_mode; }
void set_credentials_mode(CredentialsMode credentials_mode) { m_credentials_mode = credentials_mode; }
[[nodiscard]] bool use_url_credentials() const { return m_use_url_credentials; }
void set_use_url_credentials(bool use_url_credentials) { m_use_url_credentials = use_url_credentials; }
[[nodiscard]] CacheMode cache_mode() const { return m_cache_mode; }
void set_cache_mode(CacheMode cache_mode) { m_cache_mode = cache_mode; }
[[nodiscard]] RedirectMode redirect_mode() const { return m_redirect_mode; }
void set_redirect_mode(RedirectMode redirect_mode) { m_redirect_mode = redirect_mode; }
LibWeb/Fetch: Port infrastructure to new String
2023-03-02 23:26:35 +00:00
[[nodiscard]] String const& integrity_metadata() const { return m_integrity_metadata; }
void set_integrity_metadata(String integrity_metadata) { m_integrity_metadata = move(integrity_metadata); }
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
LibWeb/Fetch: Port infrastructure to new String
2023-03-02 23:26:35 +00:00
[[nodiscard]] String const& cryptographic_nonce_metadata() const { return m_cryptographic_nonce_metadata; }
void set_cryptographic_nonce_metadata(String cryptographic_nonce_metadata) { m_cryptographic_nonce_metadata = move(cryptographic_nonce_metadata); }
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
[[nodiscard]] Optional<ParserMetadata> const& parser_metadata() const { return m_parser_metadata; }
void set_parser_metadata(Optional<ParserMetadata> parser_metadata) { m_parser_metadata = move(parser_metadata); }
[[nodiscard]] bool reload_navigation() const { return m_reload_navigation; }
void set_reload_navigation(bool reload_navigation) { m_reload_navigation = reload_navigation; }
[[nodiscard]] bool history_navigation() const { return m_history_navigation; }
void set_history_navigation(bool history_navigation) { m_history_navigation = history_navigation; }
[[nodiscard]] bool user_activation() const { return m_user_activation; }
void set_user_activation(bool user_activation) { m_user_activation = user_activation; }
[[nodiscard]] bool render_blocking() const { return m_render_blocking; }
void set_render_blocking(bool render_blocking) { m_render_blocking = render_blocking; }
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 16:22:27 +13:00
[[nodiscard]] Vector<URL::URL> const& url_list() const { return m_url_list; }
[[nodiscard]] Vector<URL::URL>& url_list() { return m_url_list; }
void set_url_list(Vector<URL::URL> url_list) { m_url_list = move(url_list); }
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
[[nodiscard]] u8 redirect_count() const { return m_redirect_count; }
void set_redirect_count(u8 redirect_count) { m_redirect_count = redirect_count; }
LibWeb: Add referrer accessors to Fetch Request
2022-09-20 10:47:24 +02:00
[[nodiscard]] ReferrerType const& referrer() const { return m_referrer; }
void set_referrer(ReferrerType referrer) { m_referrer = move(referrer); }
LibWeb: Consistently use the EmptyString state of ReferrerPolicy We previously used an empty optional to denote that a ReferrerPolicy is in the default empty string state. However, later additions added an explicit EmptyString state. This patch moves all users to the explicit state, and stops using `Optional<ReferrerPolicy>` everywhere except for when an option not being passed from JavaScript has meaning.
2024-03-05 09:35:25 -07:00
[[nodiscard]] ReferrerPolicy::ReferrerPolicy const& referrer_policy() const { return m_referrer_policy; }
void set_referrer_policy(ReferrerPolicy::ReferrerPolicy referrer_policy) { m_referrer_policy = move(referrer_policy); }
LibWeb: Add referrer policy to Fetch::Infrastructure::Request The enum is in its own directory and namespace as there's a standalone spec for it, that will later also house AOs. - https://w3c.github.io/webappsec-referrer-policy/ - https://www.w3.org/TR/referrer-policy/
2022-09-24 00:29:45 +01:00
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
[[nodiscard]] ResponseTainting response_tainting() const { return m_response_tainting; }
void set_response_tainting(ResponseTainting response_tainting) { m_response_tainting = response_tainting; }
[[nodiscard]] bool prevent_no_cache_cache_control_header_modification() const { return m_prevent_no_cache_cache_control_header_modification; }
void set_prevent_no_cache_cache_control_header_modification(bool prevent_no_cache_cache_control_header_modification) { m_prevent_no_cache_cache_control_header_modification = prevent_no_cache_cache_control_header_modification; }
[[nodiscard]] bool done() const { return m_done; }
void set_done(bool done) { m_done = done; }
[[nodiscard]] bool timing_allow_failed() const { return m_timing_allow_failed; }
void set_timing_allow_failed(bool timing_allow_failed) { m_timing_allow_failed = timing_allow_failed; }
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 16:22:27 +13:00
[[nodiscard]] URL::URL& url();
[[nodiscard]] URL::URL const& url() const;
[[nodiscard]] URL::URL& current_url();
[[nodiscard]] URL::URL const& current_url() const;
void set_url(URL::URL url);
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
[[nodiscard]] bool destination_is_script_like() const;
[[nodiscard]] bool is_subresource_request() const;
[[nodiscard]] bool is_non_subresource_request() const;
[[nodiscard]] bool is_navigation_request() const;
[[nodiscard]] bool has_redirect_tainted_origin() const;
LibWeb: Remove OOM propagation from Fetch::Infrastructure::Requests
2024-04-26 13:35:10 -04:00
[[nodiscard]] String serialize_origin() const;
[[nodiscard]] ByteBuffer byte_serialize_origin() const;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
LibJS: Make Heap::allocate<T>() infallible Stop worrying about tiny OOMs. Work towards #20449. While going through these, I also changed the function signature in many places where returning ThrowCompletionOr<T> is no longer necessary.
2023-08-13 13:05:26 +02:00
[[nodiscard]] JS::NonnullGCPtr<Request> clone(JS::Realm&) const;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
LibWeb: Remove OOM propagation from Fetch::Infrastructure::Requests
2024-04-26 13:35:10 -04:00
void add_range_header(u64 first, Optional<u64> const& last);
void add_origin_header();
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
[[nodiscard]] bool cross_origin_embedder_policy_allows_credentials() const;
LibWeb: Register PendingResponse with a Request to keep it alive This was an oversight from when I converted PendingResponse and various other classes from being ref-counted to GC-allocated last minute - no one takes care to keep all of them alive. Some are on the stack, and some might be captured in another PendingResponse's JS::SafeFunction, but ultimately, we need a better solution. Since a PendingResponse is *always* the result of someone having created a Request, let's just let that keep a list of each PendingResponse that has been created for it, and visit them until they are resolved. After that, they can be GC'd with no complaints.
2022-11-01 19:35:38 +00:00
// Non-standard
void add_pending_response(Badge<Fetching::PendingResponse>, JS::NonnullGCPtr<Fetching::PendingResponse> pending_response)
{
VERIFY(!m_pending_responses.contains_slow(pending_response));
m_pending_responses.append(pending_response);
}
void remove_pending_response(Badge<Fetching::PendingResponse>, JS::NonnullGCPtr<Fetching::PendingResponse> pending_response)
{
m_pending_responses.remove_first_matching([&](auto gc_ptr) { return gc_ptr == pending_response; });
}
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
private:
LibWeb: Make Fetch::Infrastructure::{Request,Response,HeaderList} GC'd This is the way. On a more serious note, there's no reason to keep adding ref-counted classes to LibWeb now that the majority of classes is GC'd - it only adds the risk of discovering some cycle down the line, and forces us to use handles as we can't visit().
2022-10-30 01:52:07 +00:00
explicit Request(JS::NonnullGCPtr<HeaderList>);
virtual void visit_edges(JS::Cell::Visitor&) override;
LibWeb: Make Fetch::Infrastructure::{Request,Response} ref-counted With the addition of the 'fetch params' struct, the single ownership model we had so far falls apart completely. Additionally, this works nicely for FilteredResponse's internal response instead of risking a dangling reference. Replacing the public constructor with a create() function also found a few instances of a Request being stack-allocated!
2022-10-04 23:45:47 +01:00
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// https://fetch.spec.whatwg.org/#concept-request-method
// A request has an associated method (a method). Unless stated otherwise it is `GET`.
LibWeb: Make Fetch::Infrastructure::Request::m_method default to "GET" ByteBuffer has an inline capacity of 32 bytes, so this isn't fallible and can be done inline.
2022-09-25 19:28:48 +01:00
ByteBuffer m_method { ByteBuffer::copy("GET"sv.bytes()).release_value() };
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// https://fetch.spec.whatwg.org/#local-urls-only-flag
// A request has an associated local-URLs-only flag. Unless stated otherwise it is unset.
bool m_local_urls_only { false };
// https://fetch.spec.whatwg.org/#concept-request-header-list
// A request has an associated header list (a header list). Unless stated otherwise it is empty.
LibWeb: Make Fetch::Infrastructure::{Request,Response,HeaderList} GC'd This is the way. On a more serious note, there's no reason to keep adding ref-counted classes to LibWeb now that the majority of classes is GC'd - it only adds the risk of discovering some cycle down the line, and forces us to use handles as we can't visit().
2022-10-30 01:52:07 +00:00
JS::NonnullGCPtr<HeaderList> m_header_list;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// https://fetch.spec.whatwg.org/#unsafe-request-flag
// A request has an associated unsafe-request flag. Unless stated otherwise it is unset.
bool m_unsafe_request { false };
// https://fetch.spec.whatwg.org/#concept-request-body
// A request has an associated body (null, a byte sequence, or a body). Unless stated otherwise it is null.
BodyType m_body;
// https://fetch.spec.whatwg.org/#concept-request-client
// A request has an associated client (null or an environment settings object).
LibJS+LibWeb: Wrap raw JS::Cell*/& fields in GCPtr/NonnullGCPtr
2023-02-26 16:09:02 -07:00
JS::GCPtr<HTML::EnvironmentSettingsObject> m_client;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// https://fetch.spec.whatwg.org/#concept-request-reserved-client
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated reserved client (null, an environment, or an environment settings object). Unless
// stated otherwise it is null.
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
ReservedClientType m_reserved_client;
// https://fetch.spec.whatwg.org/#concept-request-replaces-client-id
// A request has an associated replaces client id (a string). Unless stated otherwise it is the empty string.
LibWeb/Fetch: Port infrastructure to new String
2023-03-02 23:26:35 +00:00
String m_replaces_client_id;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// https://fetch.spec.whatwg.org/#concept-request-window
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated window ("no-window", "client", or an environment settings object whose global object
// is a Window object). Unless stated otherwise it is "client".
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
WindowType m_window { Window::Client };
// https://fetch.spec.whatwg.org/#request-keepalive-flag
// A request has an associated boolean keepalive. Unless stated otherwise it is false.
bool m_keepalive { false };
// https://fetch.spec.whatwg.org/#request-initiator-type
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated initiator type, which is null, "audio", "beacon", "body", "css", "early-hint",
// "embed", "fetch", "font", "frame", "iframe", "image", "img", "input", "link", "object", "ping", "script",
// "track", "video", "xmlhttprequest", or "other". Unless stated otherwise it is null. [RESOURCE-TIMING]
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
Optional<InitiatorType> m_initiator_type;
// https://fetch.spec.whatwg.org/#request-service-workers-mode
// A request has an associated service-workers mode, that is "all" or "none". Unless stated otherwise it is "all".
ServiceWorkersMode m_service_workers_mode { ServiceWorkersMode::All };
// https://fetch.spec.whatwg.org/#concept-request-initiator
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated initiator, which is the empty string, "download", "imageset", "manifest",
// "prefetch", "prerender", or "xslt". Unless stated otherwise it is the empty string.
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
Optional<Initiator> m_initiator;
// https://fetch.spec.whatwg.org/#concept-request-destination
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated destination, which is the empty string, "audio", "audioworklet", "document",
LibWeb/Fetch: Add "json" destination for JSON modules This is a change in the Fetch spec. See: - https://github.com/whatwg/fetch/commit/49bff76
2024-04-29 20:11:02 +01:00
// "embed", "font", "frame", "iframe", "image", "json", "manifest", "object", "paintworklet", "report", "script",
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// "serviceworker", "sharedworker", "style", "track", "video", "webidentity", "worker", or "xslt". Unless stated
// otherwise it is the empty string.
// NOTE: These are reflected on RequestDestination except for "serviceworker" and "webidentity" as fetches with
// those destinations skip service workers.
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
Optional<Destination> m_destination;
LibWeb/Fetch: Implement changes to priority This patch updates the priority member of fetch requests to be an enum. The implementation defined struct previously named Priority has been renamed to InternalPriority in line with the spec.
2023-10-29 02:49:22 +01:00
// https://fetch.spec.whatwg.org/#request-priority
// A request has an associated priority, which is "high", "low", or "auto". Unless stated otherwise it is "auto".
Priority m_priority { Priority::Auto };
// https://fetch.spec.whatwg.org/#request-internal-priority
// A request has an associated internal priority (null or an implementation-defined object). Unless otherwise stated it is null.
Optional<InternalPriority> m_internal_priority;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// https://fetch.spec.whatwg.org/#concept-request-origin
// A request has an associated origin, which is "client" or an origin. Unless stated otherwise it is "client".
OriginType m_origin { Origin::Client };
// https://fetch.spec.whatwg.org/#concept-request-policy-container
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated policy container, which is "client" or a policy container. Unless stated otherwise
// it is "client".
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
PolicyContainerType m_policy_container { PolicyContainer::Client };
// https://fetch.spec.whatwg.org/#concept-request-referrer
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated referrer, which is "no-referrer", "client", or a URL. Unless stated otherwise it is
// "client".
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
ReferrerType m_referrer { Referrer::Client };
// https://fetch.spec.whatwg.org/#concept-request-referrer-policy
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated referrer policy, which is a referrer policy. Unless stated otherwise it is the empty
// string.
LibWeb: Consistently use the EmptyString state of ReferrerPolicy We previously used an empty optional to denote that a ReferrerPolicy is in the default empty string state. However, later additions added an explicit EmptyString state. This patch moves all users to the explicit state, and stops using `Optional<ReferrerPolicy>` everywhere except for when an option not being passed from JavaScript has meaning.
2024-03-05 09:35:25 -07:00
ReferrerPolicy::ReferrerPolicy m_referrer_policy { ReferrerPolicy::ReferrerPolicy::EmptyString };
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// https://fetch.spec.whatwg.org/#concept-request-mode
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated mode, which is "same-origin", "cors", "no-cors", "navigate", or "websocket". Unless
// stated otherwise, it is "no-cors".
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
Mode m_mode { Mode::NoCORS };
// https://fetch.spec.whatwg.org/#use-cors-preflight-flag
// A request has an associated use-CORS-preflight flag. Unless stated otherwise, it is unset.
bool m_use_cors_preflight { false };
// https://fetch.spec.whatwg.org/#concept-request-credentials-mode
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated credentials mode, which is "omit", "same-origin", or "include". Unless stated
// otherwise, it is "same-origin".
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
CredentialsMode m_credentials_mode { CredentialsMode::SameOrigin };
// https://fetch.spec.whatwg.org/#concept-request-use-url-credentials-flag
// A request has an associated use-URL-credentials flag. Unless stated otherwise, it is unset.
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// NOTE: When this flag is set, when a request’s URL has a username and password, and there is an available
// authentication entry for the request, then the URL’s credentials are preferred over that of the
// authentication entry. Modern specifications avoid setting this flag, since putting credentials in URLs is
// discouraged, but some older features set it for compatibility reasons.
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
bool m_use_url_credentials { false };
// https://fetch.spec.whatwg.org/#concept-request-cache-mode
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated cache mode, which is "default", "no-store", "reload", "no-cache", "force-cache", or
// "only-if-cached". Unless stated otherwise, it is "default".
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
CacheMode m_cache_mode { CacheMode::Default };
LibWeb: Add missing links to Fetch::Infrastructure::Request members
2022-10-04 23:41:48 +01:00
// https://fetch.spec.whatwg.org/#concept-request-redirect-mode
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated redirect mode, which is "follow", "error", or "manual". Unless stated otherwise, it
// is "follow".
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
RedirectMode m_redirect_mode { RedirectMode::Follow };
LibWeb: Add missing links to Fetch::Infrastructure::Request members
2022-10-04 23:41:48 +01:00
// https://fetch.spec.whatwg.org/#concept-request-integrity-metadata
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// A request has associated integrity metadata (a string). Unless stated otherwise, it is the empty string.
LibWeb/Fetch: Port infrastructure to new String
2023-03-02 23:26:35 +00:00
String m_integrity_metadata;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
LibWeb: Add missing links to Fetch::Infrastructure::Request members
2022-10-04 23:41:48 +01:00
// https://fetch.spec.whatwg.org/#concept-request-nonce-metadata
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has associated cryptographic nonce metadata (a string). Unless stated otherwise, it is the empty
// string.
LibWeb/Fetch: Port infrastructure to new String
2023-03-02 23:26:35 +00:00
String m_cryptographic_nonce_metadata;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
LibWeb: Add missing links to Fetch::Infrastructure::Request members
2022-10-04 23:41:48 +01:00
// https://fetch.spec.whatwg.org/#concept-request-parser-metadata
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has associated parser metadata which is the empty string, "parser-inserted", or
// "not-parser-inserted". Unless otherwise stated, it is the empty string.
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
Optional<ParserMetadata> m_parser_metadata;
LibWeb: Add missing links to Fetch::Infrastructure::Request members
2022-10-04 23:41:48 +01:00
// https://fetch.spec.whatwg.org/#concept-request-reload-navigation-flag
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// A request has an associated reload-navigation flag. Unless stated otherwise, it is unset.
bool m_reload_navigation { false };
// https://fetch.spec.whatwg.org/#concept-request-history-navigation-flag
// A request has an associated history-navigation flag. Unless stated otherwise, it is unset.
bool m_history_navigation { false };
// https://fetch.spec.whatwg.org/#request-user-activation
// A request has an associated boolean user-activation. Unless stated otherwise, it is false.
bool m_user_activation { false };
// https://fetch.spec.whatwg.org/#request-render-blocking
// A request has an associated boolean render-blocking. Unless stated otherwise, it is false.
bool m_render_blocking { false };
// https://fetch.spec.whatwg.org/#concept-request-url-list
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated URL list (a list of one or more URLs). Unless stated otherwise, it is a list
// containing a copy of request’s URL.
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 16:22:27 +13:00
Vector<URL::URL> m_url_list;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// https://fetch.spec.whatwg.org/#concept-request-redirect-count
// A request has an associated redirect count. Unless stated otherwise, it is zero.
// NOTE: '4.4. HTTP-redirect fetch' infers a limit of 20.
u8 m_redirect_count { 0 };
// https://fetch.spec.whatwg.org/#concept-request-response-tainting
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated response tainting, which is "basic", "cors", or "opaque". Unless stated otherwise,
// it is "basic".
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
ResponseTainting m_response_tainting { ResponseTainting::Basic };
// https://fetch.spec.whatwg.org/#no-cache-prevent-cache-control
LibWeb: Explain the use-URL-credentials flag This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/a388348
2022-10-30 14:41:36 +00:00
// A request has an associated prevent no-cache cache-control header modification flag. Unless stated otherwise, it
// is unset.
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
bool m_prevent_no_cache_cache_control_header_modification { false };
// https://fetch.spec.whatwg.org/#done-flag
// A request has an associated done flag. Unless stated otherwise, it is unset.
bool m_done { false };
// https://fetch.spec.whatwg.org/#timing-allow-failed
// A request has an associated timing allow failed flag. Unless stated otherwise, it is unset.
bool m_timing_allow_failed { false };
LibWeb: Register PendingResponse with a Request to keep it alive This was an oversight from when I converted PendingResponse and various other classes from being ref-counted to GC-allocated last minute - no one takes care to keep all of them alive. Some are on the stack, and some might be captured in another PendingResponse's JS::SafeFunction, but ultimately, we need a better solution. Since a PendingResponse is *always* the result of someone having created a Request, let's just let that keep a list of each PendingResponse that has been created for it, and visit them until they are resolved. After that, they can be GC'd with no complaints.
2022-11-01 19:35:38 +00:00
// Non-standard
Vector<JS::NonnullGCPtr<Fetching::PendingResponse>> m_pending_responses;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
};
}
Reference in a new issue Copy permalink