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/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Requests.cpp

454 lines
17 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: 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
*/
#include <AK/Array.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/Heap.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/Runtime/Realm.h>
LibWeb: Rename URL platform object to DOMURL Along with putting functions in the URL namespace into a DOMURL namespace. This is done as LibWeb is in an awkward situation where it needs two URL classes. AK::URL is the general purpose URL class which is all that is needed in 95% of cases. URL in the Web namespace is needed predominantly for interfacing with the javascript interfaces. Because of two URLs in the same namespace, AK::URL has had to be used throughout LibWeb. If we move AK::URL into a URL namespace, this becomes more painful - where ::URL::URL is required to specify the constructor (and something like ::URL::create_with_url_or_path in other places). To fix this problem - rename the class in LibWeb implementing the URL IDL interface to DOMURL, along with moving the other Web URL related classes into this DOMURL folder. One could argue that this name also makes the situation a little more clear in LibWeb for why these two URL classes need be used in the first place.
2024-02-11 19:48:56 +13:00
#include <LibWeb/DOMURL/DOMURL.h>
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
#include <LibWeb/Fetch/Fetching/PendingResponse.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/Requests.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
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_DEFINE_ALLOCATOR(Request);
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
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
Request::Request(GC::Ref<HeaderList> header_list)
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
: m_header_list(header_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
{
}
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
void Request::visit_edges(JS::Cell::Visitor& visitor)
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: 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
Base::visit_edges(visitor);
visitor.visit(m_header_list);
LibJS+LibWeb: Add missing visit calls in visit_edges implementations
2023-03-21 10:08:44 -07:00
visitor.visit(m_client);
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
m_body.visit(
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) { visitor.visit(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
[](auto&) {});
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
visitor.visit(m_reserved_client);
LibJS+LibWeb: Add missing visit calls in visit_edges implementations
2023-03-21 10:08:44 -07:00
m_window.visit(
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::Ptr<HTML::EnvironmentSettingsObject> const& value) { visitor.visit(value); },
LibJS+LibWeb: Add missing visit calls in visit_edges implementations
2023-03-21 10:08:44 -07:00
[](auto const&) {});
LibJS+LibWeb: Use new Cell::Visitor helpers to avoid manual iteration
2024-04-15 13:58:21 +02:00
visitor.visit(m_pending_responses);
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
}
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<Request> Request::create(JS::VM& vm)
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
{
LibJS+LibWeb: Rename Heap::allocate_without_realm to Heap::allocate Now that the heap has no knowledge about a JavaScript realm and is purely for managing the memory of the heap, it does not make sense to name this function to say that it is a non-realm variant.
2024-11-14 06:13:46 +13:00
return vm.heap().allocate<Request>(HeaderList::create(vm));
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-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
URL::URL& Request::url()
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 URL (a URL).
// NOTE: Implementations are encouraged to make this a pointer to the first URL in request’s URL list. It is provided as a distinct field solely for the convenience of other standards hooking into Fetch.
VERIFY(!m_url_list.is_empty());
return m_url_list.first();
}
LibWeb: Add non-const variants of Request::{current_,}url()
2022-10-13 19:35:37 +02:00
// https://fetch.spec.whatwg.org/#concept-request-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
URL::URL const& Request::url() const
LibWeb: Add non-const variants of Request::{current_,}url()
2022-10-13 19:35:37 +02:00
{
return const_cast<Request&>(*this).url();
}
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-current-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
URL::URL& Request::current_url()
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 current URL. It is a pointer to the last URL in request’s URL list.
VERIFY(!m_url_list.is_empty());
return m_url_list.last();
}
LibWeb: Add non-const variants of Request::{current_,}url()
2022-10-13 19:35:37 +02:00
// https://fetch.spec.whatwg.org/#concept-request-current-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
URL::URL const& Request::current_url() const
LibWeb: Add non-const variants of Request::{current_,}url()
2022-10-13 19:35:37 +02:00
{
return const_cast<Request&>(*this).current_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
void Request::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
{
// Sometimes setting the URL and URL list are done as two distinct steps in the spec,
// but since we know the URL is always the URL list's first item and doesn't change later
// on, we can combine them.
LibWeb: Implement '5.4. Request class' from the Fetch API :^)
2022-09-25 19:33:13 +01:00
if (!m_url_list.is_empty())
m_url_list.clear();
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
m_url_list.append(move(url));
}
// https://fetch.spec.whatwg.org/#request-destination-script-like
bool Request::destination_is_script_like() const
{
// A request’s destination is script-like if it is "audioworklet", "paintworklet", "script", "serviceworker", "sharedworker", or "worker".
static constexpr Array script_like_destinations = {
Destination::AudioWorklet,
Destination::PaintWorklet,
Destination::Script,
Destination::ServiceWorker,
Destination::SharedWorker,
Destination::Worker,
};
return any_of(script_like_destinations, [this](auto destination) {
return m_destination == destination;
});
}
// https://fetch.spec.whatwg.org/#subresource-request
bool Request::is_subresource_request() const
{
LibWeb/Fetch: Use "json" destination See: - https://github.com/SerenityOS/serenity/commit/da8d0d8 - https://github.com/whatwg/fetch/commit/49bff76 - https://github.com/whatwg/html/commit/37659e9
2024-05-03 20:44:06 +01:00
// A subresource request is a request whose destination is "audio", "audioworklet", "font", "image", "json", "manifest", "paintworklet", "script", "style", "track", "video", "xslt", or the empty string.
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
static constexpr Array subresource_request_destinations = {
Destination::Audio,
Destination::AudioWorklet,
Destination::Font,
Destination::Image,
LibWeb/Fetch: Use "json" destination See: - https://github.com/SerenityOS/serenity/commit/da8d0d8 - https://github.com/whatwg/fetch/commit/49bff76 - https://github.com/whatwg/html/commit/37659e9
2024-05-03 20:44:06 +01:00
Destination::JSON,
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
Destination::Manifest,
Destination::PaintWorklet,
Destination::Script,
Destination::Style,
Destination::Track,
Destination::Video,
Destination::XSLT,
};
return any_of(subresource_request_destinations, [this](auto destination) {
return m_destination == destination;
}) || !m_destination.has_value();
}
// https://fetch.spec.whatwg.org/#non-subresource-request
bool Request::is_non_subresource_request() const
{
// A non-subresource request is a request whose destination is "document", "embed", "frame", "iframe", "object", "report", "serviceworker", "sharedworker", or "worker".
static constexpr Array non_subresource_request_destinations = {
Destination::Document,
Destination::Embed,
Destination::Frame,
Destination::IFrame,
Destination::Object,
Destination::Report,
Destination::ServiceWorker,
Destination::SharedWorker,
Destination::Worker,
};
return any_of(non_subresource_request_destinations, [this](auto destination) {
return m_destination == destination;
});
}
// https://fetch.spec.whatwg.org/#navigation-request
bool Request::is_navigation_request() const
{
// A navigation request is a request whose destination is "document", "embed", "frame", "iframe", or "object".
static constexpr Array navigation_request_destinations = {
Destination::Document,
Destination::Embed,
Destination::Frame,
Destination::IFrame,
Destination::Object,
};
return any_of(navigation_request_destinations, [this](auto destination) {
return m_destination == destination;
});
}
// https://fetch.spec.whatwg.org/#concept-request-tainted-origin
bool Request::has_redirect_tainted_origin() const
{
// A request request has a redirect-tainted origin if these steps return true:
// 1. Let lastURL be null.
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
Optional<URL::URL const&> last_url;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
LibWeb/Fetch: Tweak wording in some spec comments This is a change in the Fetch spec. See: https://github.com/whatwg/fetch/commit/223ca89
2022-12-07 18:29:17 +00:00
// 2. For each url of request’s URL list:
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
for (auto const& url : m_url_list) {
// 1. If lastURL is null, then set lastURL to url and continue.
if (!last_url.has_value()) {
last_url = url;
continue;
}
// 2. If url’s origin is not same origin with lastURL’s origin and request’s origin is not same origin with lastURL’s origin, then return true.
LibWeb+LibURL: Move HTML::Origin to URL::Origin While Origin is defined in the HTML spec - this leaves us with quite an awkward relationship as the URL spec makes use of AO's from what is defined in the HTML spec. To simplify this factoring, relocate Origin into LibURL.
2024-10-05 15:33:34 +13:00
auto const* request_origin = m_origin.get_pointer<URL::Origin>();
LibWeb+LibURL: Consolidate Origin parsing and serialization into LibURL Because of the previous awkward factoring of Origin we had two implementations of Origin serializing and creation. Move the implementation of DOMURL::url_origin into URL::origin, and instead use the implemenation of URL::Origin::serialize for serialization (replacing URL::serialize_origin). This happens to fix 8 URL subtests as the two implemenations had diverged, and URL::serialize_origin was previously missing the spec changes of: whatwg/url@eee49fd and whatwg/url@fff33c3
2024-10-05 17:03:51 +13:00
if (!url.origin().is_same_origin(last_url->origin())
&& (request_origin == nullptr || !request_origin->is_same_origin(last_url->origin()))) {
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
return true;
LibWeb: Use proper origins in Request::has_redirect_tainted_origin() URL::url_origin() is a globally available function now, so let's use it!
2022-10-31 18:04:11 +00:00
}
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// 3. Set lastURL to url.
last_url = url;
}
// 3. Return false.
return false;
}
// https://fetch.spec.whatwg.org/#serializing-a-request-origin
LibWeb: Remove OOM propagation from Fetch::Infrastructure::Requests
2024-04-26 13:35:10 -04:00
String Request::serialize_origin() const
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
{
// 1. If request has a redirect-tainted origin, then return "null".
if (has_redirect_tainted_origin())
LibWeb/Fetch: Port infrastructure to new String
2023-03-02 23:26:35 +00:00
return "null"_string;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// 2. Return request’s origin, serialized.
LibURL+LibWeb: Make URL serialization return a String This can only ever fail from OOM, and will never by string containing random byte sequences.
2024-11-23 20:10:34 +13:00
return m_origin.get<URL::Origin>().serialize();
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/#byte-serializing-a-request-origin
LibWeb: Remove OOM propagation from Fetch::Infrastructure::Requests
2024-04-26 13:35:10 -04:00
ByteBuffer Request::byte_serialize_origin() const
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
{
// Byte-serializing a request origin, given a request request, is to return the result of serializing a request origin with request, isomorphic encoded.
LibWeb: Remove OOM propagation from Fetch::Infrastructure::Requests
2024-04-26 13:35:10 -04:00
return MUST(ByteBuffer::copy(serialize_origin().bytes()));
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-clone
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<Request> Request::clone(JS::Realm& realm) const
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
{
// To clone a request request, run these steps:
LibWeb: Propagate Realm instead of VM more through Fetch This makes Fetch rely less on using main_thread_vm().current_realm(), which relies on the dummy execution context if no JavaScript is currently running.
2023-02-28 17:45:49 +00:00
auto& vm = realm.vm();
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// 1. Let newRequest be a copy of request, except for its body.
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
auto new_request = Infrastructure::Request::create(vm);
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
new_request->set_method(m_method);
new_request->set_local_urls_only(m_local_urls_only);
for (auto const& header : *m_header_list)
LibWeb: Remove OOM propagation from Fetch::Infrastructure::Headers
2024-04-26 13:24:20 -04:00
new_request->header_list()->append(header);
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
new_request->set_unsafe_request(m_unsafe_request);
new_request->set_client(m_client);
new_request->set_reserved_client(m_reserved_client);
new_request->set_replaces_client_id(m_replaces_client_id);
new_request->set_window(m_window);
new_request->set_keepalive(m_keepalive);
new_request->set_initiator_type(m_initiator_type);
new_request->set_service_workers_mode(m_service_workers_mode);
new_request->set_initiator(m_initiator);
new_request->set_destination(m_destination);
new_request->set_priority(m_priority);
new_request->set_origin(m_origin);
new_request->set_policy_container(m_policy_container);
new_request->set_referrer(m_referrer);
new_request->set_referrer_policy(m_referrer_policy);
new_request->set_mode(m_mode);
new_request->set_use_cors_preflight(m_use_cors_preflight);
new_request->set_credentials_mode(m_credentials_mode);
new_request->set_use_url_credentials(m_use_url_credentials);
new_request->set_cache_mode(m_cache_mode);
new_request->set_redirect_mode(m_redirect_mode);
new_request->set_integrity_metadata(m_integrity_metadata);
new_request->set_cryptographic_nonce_metadata(m_cryptographic_nonce_metadata);
new_request->set_parser_metadata(m_parser_metadata);
new_request->set_reload_navigation(m_reload_navigation);
new_request->set_history_navigation(m_history_navigation);
new_request->set_user_activation(m_user_activation);
new_request->set_render_blocking(m_render_blocking);
new_request->set_url_list(m_url_list);
new_request->set_redirect_count(m_redirect_count);
new_request->set_response_tainting(m_response_tainting);
new_request->set_prevent_no_cache_cache_control_header_modification(m_prevent_no_cache_cache_control_header_modification);
new_request->set_done(m_done);
new_request->set_timing_allow_failed(m_timing_allow_failed);
LibWeb: Support unbuffered fetch requests Supporting unbuffered fetches is actually part of the fetch spec in its HTTP-network-fetch algorithm. We had previously implemented this method in a very ad-hoc manner as a simple wrapper around ResourceLoader. This is still the case, but we now implement a good amount of these steps according to spec, using ResourceLoader's unbuffered API. The response data is forwarded through to the fetch response using streams. This will eventually let us remove the use of ResourceLoader's buffered API, as all responses should just be streamed this way. The streams spec then supplies ways to wait for completion, thus allowing fully buffered responses. However, we have more work to do to make the other parts of our fetch implementation (namely, Body::fully_read) use streams before we can do this.
2024-05-26 08:03:29 -04:00
new_request->set_buffer_policy(m_buffer_policy);
LibWeb: Stub out Fetch::Infrastructure::Body::clone()
2022-09-25 19:25:53 +01:00
// 2. If request’s body is non-null, set newRequest’s body to the result of cloning request’s body.
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
if (auto const* body = m_body.get_pointer<GC::Ref<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
new_request->set_body((*body)->clone(realm));
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// 3. Return newRequest.
return new_request;
}
// https://fetch.spec.whatwg.org/#concept-request-add-range-header
LibWeb: Remove OOM propagation from Fetch::Infrastructure::Requests
2024-04-26 13:35:10 -04:00
void Request::add_range_header(u64 first, Optional<u64> const& last)
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
{
// To add a range header to a request request, with an integer first, and an optional integer last, run these steps:
// 1. Assert: last is not given, or first is less than or equal to last.
VERIFY(!last.has_value() || first <= last.value());
// 2. Let rangeValue be `bytes=`.
LibWeb: Use MUST() for infallible ByteBuffer::copy() invocations ByteBuffer has an inline capacity of 32 bytes, so when we provide a string smaller than that, it cannot fail.
2022-10-24 09:21:12 +01:00
auto range_value = MUST(ByteBuffer::copy("bytes"sv.bytes()));
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// 3. Serialize and isomorphic encode first, and append the result to rangeValue.
AK: Make String::number() infallible This API will always succeed in creating a String representing the provided number in base-10.
2024-10-14 10:05:01 +02:00
range_value.append(String::number(first).bytes());
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// 4. Append 0x2D (-) to rangeValue.
LibWeb: Remove OOM propagation from Fetch::Infrastructure::Requests
2024-04-26 13:35:10 -04:00
range_value.append('-');
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// 5. If last is given, then serialize and isomorphic encode it, and append the result to rangeValue.
if (last.has_value())
AK: Make String::number() infallible This API will always succeed in creating a String representing the provided number in base-10.
2024-10-14 10:05:01 +02:00
range_value.append(String::number(*last).bytes());
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// 6. Append (`Range`, rangeValue) to request’s header list.
auto header = Header {
LibWeb: Use MUST() for infallible ByteBuffer::copy() invocations ByteBuffer has an inline capacity of 32 bytes, so when we provide a string smaller than that, it cannot fail.
2022-10-24 09:21:12 +01:00
.name = MUST(ByteBuffer::copy("Range"sv.bytes())),
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
.value = move(range_value),
};
LibWeb: Remove OOM propagation from Fetch::Infrastructure::Headers
2024-04-26 13:24:20 -04:00
m_header_list->append(move(header));
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
}
LibWeb: Implement 'Append a request `Origin` header' AO
2022-10-24 09:18:51 +01:00
// https://fetch.spec.whatwg.org/#append-a-request-origin-header
LibWeb: Remove OOM propagation from Fetch::Infrastructure::Requests
2024-04-26 13:35:10 -04:00
void Request::add_origin_header()
LibWeb: Implement 'Append a request `Origin` header' AO
2022-10-24 09:18:51 +01:00
{
// 1. Let serializedOrigin be the result of byte-serializing a request origin with request.
LibWeb: Remove OOM propagation from Fetch::Infrastructure::Requests
2024-04-26 13:35:10 -04:00
auto serialized_origin = byte_serialize_origin();
LibWeb: Implement 'Append a request `Origin` header' AO
2022-10-24 09:18:51 +01:00
// 2. If request’s response tainting is "cors" or request’s mode is "websocket", then append (`Origin`, serializedOrigin) to request’s header list.
if (m_response_tainting == ResponseTainting::CORS || m_mode == Mode::WebSocket) {
auto header = Header {
.name = MUST(ByteBuffer::copy("Origin"sv.bytes())),
.value = move(serialized_origin),
};
LibWeb: Remove OOM propagation from Fetch::Infrastructure::Headers
2024-04-26 13:24:20 -04:00
m_header_list->append(move(header));
LibWeb: Implement 'Append a request `Origin` header' AO
2022-10-24 09:18:51 +01:00
}
// 3. Otherwise, if request’s method is neither `GET` nor `HEAD`, then:
else if (!StringView { m_method }.is_one_of("GET"sv, "HEAD"sv)) {
// 1. If request’s mode is not "cors", then switch on request’s referrer policy:
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
if (m_mode != Mode::CORS) {
switch (m_referrer_policy) {
LibWeb: Implement 'Append a request `Origin` header' AO
2022-10-24 09:18:51 +01:00
// -> "no-referrer"
case ReferrerPolicy::ReferrerPolicy::NoReferrer:
// Set serializedOrigin to `null`.
serialized_origin = MUST(ByteBuffer::copy("null"sv.bytes()));
break;
// -> "no-referrer-when-downgrade"
// -> "strict-origin"
// -> "strict-origin-when-cross-origin"
case ReferrerPolicy::ReferrerPolicy::NoReferrerWhenDowngrade:
case ReferrerPolicy::ReferrerPolicy::StrictOrigin:
case ReferrerPolicy::ReferrerPolicy::StrictOriginWhenCrossOrigin:
// If request’s origin is a tuple origin, its scheme is "https", and request’s current URL’s scheme is
// not "https", then set serializedOrigin to `null`.
LibWeb+LibURL: Move HTML::Origin to URL::Origin While Origin is defined in the HTML spec - this leaves us with quite an awkward relationship as the URL spec makes use of AO's from what is defined in the HTML spec. To simplify this factoring, relocate Origin into LibURL.
2024-10-05 15:33:34 +13:00
if (m_origin.has<URL::Origin>() && m_origin.get<URL::Origin>().scheme() == "https"sv && current_url().scheme() != "https"sv)
LibWeb: Implement 'Append a request `Origin` header' AO
2022-10-24 09:18:51 +01:00
serialized_origin = MUST(ByteBuffer::copy("null"sv.bytes()));
break;
// -> "same-origin"
case ReferrerPolicy::ReferrerPolicy::SameOrigin:
// If request’s origin is not same origin with request’s current URL’s origin, then set serializedOrigin
// to `null`.
LibWeb+LibURL: Consolidate Origin parsing and serialization into LibURL Because of the previous awkward factoring of Origin we had two implementations of Origin serializing and creation. Move the implementation of DOMURL::url_origin into URL::origin, and instead use the implemenation of URL::Origin::serialize for serialization (replacing URL::serialize_origin). This happens to fix 8 URL subtests as the two implemenations had diverged, and URL::serialize_origin was previously missing the spec changes of: whatwg/url@eee49fd and whatwg/url@fff33c3
2024-10-05 17:03:51 +13:00
if (m_origin.has<URL::Origin>() && !m_origin.get<URL::Origin>().is_same_origin(current_url().origin()))
LibWeb: Implement 'Append a request `Origin` header' AO
2022-10-24 09:18:51 +01:00
serialized_origin = MUST(ByteBuffer::copy("null"sv.bytes()));
break;
// -> Otherwise
default:
// Do nothing.
break;
}
}
// 2. Append (`Origin`, serializedOrigin) to request’s header list.
auto header = Header {
.name = MUST(ByteBuffer::copy("Origin"sv.bytes())),
.value = move(serialized_origin),
};
LibWeb: Remove OOM propagation from Fetch::Infrastructure::Headers
2024-04-26 13:24:20 -04:00
m_header_list->append(move(header));
LibWeb: Implement 'Append a request `Origin` header' AO
2022-10-24 09:18:51 +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/#cross-origin-embedder-policy-allows-credentials
bool Request::cross_origin_embedder_policy_allows_credentials() const
{
// 1. If request’s mode is not "no-cors", then return true.
if (m_mode != Mode::NoCORS)
return true;
// 2. If request’s client is null, then return true.
if (m_client == nullptr)
return true;
LibWeb: Implement EmbedderPolicy struct
2024-07-08 22:54:49 +01:00
// 3. If request’s client’s policy container’s embedder policy’s value is not "credentialless", then return true.
if (m_policy_container.has<HTML::PolicyContainer>() && m_policy_container.get<HTML::PolicyContainer>().embedder_policy.value != HTML::EmbedderPolicyValue::Credentialless)
return true;
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
// 4. If request’s origin is same origin with request’s current URL’s origin and request does not have a redirect-tainted origin, then return true.
// 5. Return false.
LibWeb+LibURL: Move HTML::Origin to URL::Origin While Origin is defined in the HTML spec - this leaves us with quite an awkward relationship as the URL spec makes use of AO's from what is defined in the HTML spec. To simplify this factoring, relocate Origin into LibURL.
2024-10-05 15:33:34 +13:00
auto const* request_origin = m_origin.get_pointer<URL::Origin>();
LibWeb/Fetch: Use origins in `Cross-Origin-Embedder-Policy` algorithm
2023-08-25 16:32:45 -07:00
if (request_origin == nullptr)
return false;
LibWeb+LibURL: Consolidate Origin parsing and serialization into LibURL Because of the previous awkward factoring of Origin we had two implementations of Origin serializing and creation. Move the implementation of DOMURL::url_origin into URL::origin, and instead use the implemenation of URL::Origin::serialize for serialization (replacing URL::serialize_origin). This happens to fix 8 URL subtests as the two implemenations had diverged, and URL::serialize_origin was previously missing the spec changes of: whatwg/url@eee49fd and whatwg/url@fff33c3
2024-10-05 17:03:51 +13:00
return request_origin->is_same_origin(current_url().origin()) && !has_redirect_tainted_origin();
LibWeb: Add definitions from '2.2.5 Requests' in the Fetch spec
2022-07-14 00:51:42 +01:00
}
LibWeb/Fetch: Add to_string function for Request::Destination
2024-04-29 20:22:32 +01:00
StringView request_destination_to_string(Request::Destination destination)
{
switch (destination) {
case Request::Destination::Audio:
return "audio"sv;
case Request::Destination::AudioWorklet:
return "audioworklet"sv;
case Request::Destination::Document:
return "document"sv;
case Request::Destination::Embed:
return "embed"sv;
case Request::Destination::Font:
return "font"sv;
case Request::Destination::Frame:
return "frame"sv;
case Request::Destination::IFrame:
return "iframe"sv;
case Request::Destination::Image:
return "image"sv;
case Request::Destination::JSON:
return "json"sv;
case Request::Destination::Manifest:
return "manifest"sv;
case Request::Destination::Object:
return "object"sv;
case Request::Destination::PaintWorklet:
return "paintworklet"sv;
case Request::Destination::Report:
return "report"sv;
case Request::Destination::Script:
return "script"sv;
case Request::Destination::ServiceWorker:
return "serviceworker"sv;
case Request::Destination::SharedWorker:
return "sharedworker"sv;
case Request::Destination::Style:
return "style"sv;
case Request::Destination::Track:
return "track"sv;
case Request::Destination::Video:
return "video"sv;
case Request::Destination::WebIdentity:
return "webidentity"sv;
case Request::Destination::Worker:
return "worker"sv;
case Request::Destination::XSLT:
return "xslt"sv;
}
VERIFY_NOT_REACHED();
}
LibWeb/Fetch: Add to_string function for Request::Mode
2024-04-29 20:23:26 +01:00
StringView request_mode_to_string(Request::Mode mode)
{
switch (mode) {
case Request::Mode::SameOrigin:
return "same-origin"sv;
case Request::Mode::CORS:
return "cors"sv;
case Request::Mode::NoCORS:
return "no-cors"sv;
case Request::Mode::Navigate:
return "navigate"sv;
case Request::Mode::WebSocket:
return "websocket"sv;
}
VERIFY_NOT_REACHED();
}
LibWeb: Add from_string function for request priority
2024-05-27 09:45:56 +01:00
Optional<Request::Priority> request_priority_from_string(StringView string)
{
if (string.equals_ignoring_ascii_case("high"sv))
return Request::Priority::High;
if (string.equals_ignoring_ascii_case("low"sv))
return Request::Priority::Low;
if (string.equals_ignoring_ascii_case("auto"sv))
return Request::Priority::Auto;
return {};
}
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