LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-10 13:00:29 +03:00
Code Issues Packages Projects Releases Wiki Activity
ffd3639b17
ladybird/Userland/Libraries/LibWeb/XHR/XMLHttpRequest.cpp
Andreas Kling c0d7f748ed LibWeb: Avoid FlyString lookups when setting IDL interface prototypes 
This commit introduces a WEB_SET_PROTOTYPE_FOR_INTERFACE macro that
caches the interface name in a local static FlyString. This means that
we only pay for FlyString-from-literal lookup once per browser lifetime
instead of every time the interface is instantiated.
2024-03-16 16:35:54 +01:00

1269 lines
61 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Copyright (c) 2020-2023, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2021-2023, Linus Groh <linusg@serenityos.org>
* Copyright (c) 2022-2023, Luke Wilde <lukew@serenityos.org>
* Copyright (c) 2022, Ali Mohammad Pur <mpfard@serenityos.org>
* Copyright (c) 2022-2023, Kenneth Myhra <kennethmyhra@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/ByteBuffer.h>
#include <AK/Debug.h>
#include <AK/GenericLexer.h>
#include <AK/QuickSort.h>
#include <LibJS/Runtime/ArrayBuffer.h>
#include <LibJS/Runtime/Completion.h>
#include <LibJS/Runtime/FunctionObject.h>
#include <LibJS/Runtime/GlobalObject.h>
#include <LibTextCodec/Decoder.h>
#include <LibWeb/Bindings/XMLHttpRequestPrototype.h>
#include <LibWeb/DOM/Document.h>
#include <LibWeb/DOM/DocumentLoading.h>
#include <LibWeb/DOM/Event.h>
#include <LibWeb/DOM/EventDispatcher.h>
#include <LibWeb/DOM/IDLEventListener.h>
#include <LibWeb/DOM/XMLDocument.h>
#include <LibWeb/Fetch/BodyInit.h>
#include <LibWeb/Fetch/Fetching/Fetching.h>
#include <LibWeb/Fetch/Infrastructure/FetchAlgorithms.h>
#include <LibWeb/Fetch/Infrastructure/FetchController.h>
#include <LibWeb/Fetch/Infrastructure/HTTP.h>
#include <LibWeb/Fetch/Infrastructure/HTTP/Methods.h>
#include <LibWeb/Fetch/Infrastructure/HTTP/Requests.h>
#include <LibWeb/Fetch/Infrastructure/HTTP/Responses.h>
#include <LibWeb/FileAPI/Blob.h>
#include <LibWeb/HTML/EventHandler.h>
#include <LibWeb/HTML/EventNames.h>
#include <LibWeb/HTML/Origin.h>
#include <LibWeb/HTML/Parser/HTMLEncodingDetection.h>
#include <LibWeb/HTML/Parser/HTMLParser.h>
#include <LibWeb/HTML/Window.h>
#include <LibWeb/Infra/ByteSequences.h>
#include <LibWeb/Infra/JSON.h>
#include <LibWeb/Infra/Strings.h>
#include <LibWeb/Loader/ResourceLoader.h>
#include <LibWeb/Page/Page.h>
#include <LibWeb/Platform/EventLoopPlugin.h>
#include <LibWeb/WebIDL/DOMException.h>
#include <LibWeb/WebIDL/ExceptionOr.h>
#include <LibWeb/XHR/EventNames.h>
#include <LibWeb/XHR/ProgressEvent.h>
#include <LibWeb/XHR/XMLHttpRequest.h>
#include <LibWeb/XHR/XMLHttpRequestUpload.h>
namespace Web::XHR {
JS_DEFINE_ALLOCATOR(XMLHttpRequest);
WebIDL::ExceptionOr<JS::NonnullGCPtr<XMLHttpRequest>> XMLHttpRequest::construct_impl(JS::Realm& realm)
{
auto upload_object = realm.heap().allocate<XMLHttpRequestUpload>(realm, realm);
auto author_request_headers = Fetch::Infrastructure::HeaderList::create(realm.vm());
auto response = Fetch::Infrastructure::Response::network_error(realm.vm(), "Not sent yet"sv);
auto fetch_controller = Fetch::Infrastructure::FetchController::create(realm.vm());
return realm.heap().allocate<XMLHttpRequest>(realm, realm, *upload_object, *author_request_headers, *response, *fetch_controller);
}
XMLHttpRequest::XMLHttpRequest(JS::Realm& realm, XMLHttpRequestUpload& upload_object, Fetch::Infrastructure::HeaderList& author_request_headers, Fetch::Infrastructure::Response& response, Fetch::Infrastructure::FetchController& fetch_controller)
: XMLHttpRequestEventTarget(realm)
, m_upload_object(upload_object)
, m_author_request_headers(author_request_headers)
, m_response(response)
, m_response_type(Bindings::XMLHttpRequestResponseType::Empty)
, m_fetch_controller(fetch_controller)
{
set_overrides_must_survive_garbage_collection(true);
}
XMLHttpRequest::~XMLHttpRequest() = default;
void XMLHttpRequest::initialize(JS::Realm& realm)
{
Base::initialize(realm);
WEB_SET_PROTOTYPE_FOR_INTERFACE(XMLHttpRequest);
}
void XMLHttpRequest::visit_edges(Cell::Visitor& visitor)
{
Base::visit_edges(visitor);
visitor.visit(m_upload_object);
visitor.visit(m_author_request_headers);
visitor.visit(m_request_body);
visitor.visit(m_response);
visitor.visit(m_fetch_controller);
if (auto* value = m_response_object.get_pointer<JS::NonnullGCPtr<JS::Object>>())
visitor.visit(*value);
}
// https://xhr.spec.whatwg.org/#concept-event-fire-progress
static void fire_progress_event(XMLHttpRequestEventTarget& target, FlyString const& event_name, u64 transmitted, u64 length)
{
// To fire a progress event named e at target, given transmitted and length, means to fire an event named e at target, using ProgressEvent,
// with the loaded attribute initialized to transmitted, and if length is not 0, with the lengthComputable attribute initialized to true
// and the total attribute initialized to length.
ProgressEventInit event_init {};
event_init.length_computable = true;
event_init.loaded = transmitted;
event_init.total = length;
// FIXME: If we're in an async context, this will propagate to a callback context which can't propagate it anywhere else and does not expect this to fail.
target.dispatch_event(*ProgressEvent::create(target.realm(), event_name, event_init));
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsetext
WebIDL::ExceptionOr<String> XMLHttpRequest::response_text() const
{
// 1. If this’s response type is not the empty string or "text", then throw an "InvalidStateError" DOMException.
if (m_response_type != Bindings::XMLHttpRequestResponseType::Empty && m_response_type != Bindings::XMLHttpRequestResponseType::Text)
return WebIDL::InvalidStateError::create(realm(), "XHR responseText can only be used for responseType \"\" or \"text\""_fly_string);
// 2. If this’s state is not loading or done, then return the empty string.
if (m_state != State::Loading && m_state != State::Done)
return String {};
// 3. Return the result of getting a text response for this.
return get_text_response();
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml
WebIDL::ExceptionOr<JS::GCPtr<DOM::Document>> XMLHttpRequest::response_xml()
{
// 1. If this’s response type is not the empty string or "document", then throw an "InvalidStateError" DOMException.
if (m_response_type != Bindings::XMLHttpRequestResponseType::Empty && m_response_type != Bindings::XMLHttpRequestResponseType::Document)
return WebIDL::InvalidStateError::create(realm(), "XHR responseXML can only be used for responseXML \"\" or \"document\""_fly_string);
// 2. If this’s state is not done, then return null.
if (m_state != State::Done)
return nullptr;
// 3. Assert: this’s response object is not failure.
VERIFY(!m_response_object.has<Failure>());
// 4. If this’s response object is non-null, then return it.
if (!m_response_object.has<Empty>())
return &verify_cast<DOM::Document>(*m_response_object.get<JS::NonnullGCPtr<JS::Object>>());
// 5. Set a document response for this.
set_document_response();
// 6. Return this’s response object.
if (m_response_object.has<Empty>())
return nullptr;
return &verify_cast<DOM::Document>(*m_response_object.get<JS::NonnullGCPtr<JS::Object>>());
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsetype
WebIDL::ExceptionOr<void> XMLHttpRequest::set_response_type(Bindings::XMLHttpRequestResponseType response_type)
{
// 1. If the current global object is not a Window object and the given value is "document", then return.
if (!is<HTML::Window>(HTML::current_global_object()) && response_type == Bindings::XMLHttpRequestResponseType::Document)
return {};
// 2. If this’s state is loading or done, then throw an "InvalidStateError" DOMException.
if (m_state == State::Loading || m_state == State::Done)
return WebIDL::InvalidStateError::create(realm(), "Can't readyState when XHR is loading or done"_fly_string);
// 3. If the current global object is a Window object and this’s synchronous flag is set, then throw an "InvalidAccessError" DOMException.
if (is<HTML::Window>(HTML::current_global_object()) && m_synchronous)
return WebIDL::InvalidAccessError::create(realm(), "Can't set readyState on synchronous XHR in Window environment"_fly_string);
// 4. Set this’s response type to the given value.
m_response_type = response_type;
return {};
}
// https://xhr.spec.whatwg.org/#response
WebIDL::ExceptionOr<JS::Value> XMLHttpRequest::response()
{
auto& vm = this->vm();
// 1. If this’s response type is the empty string or "text", then:
if (m_response_type == Bindings::XMLHttpRequestResponseType::Empty || m_response_type == Bindings::XMLHttpRequestResponseType::Text) {
// 1. If this’s state is not loading or done, then return the empty string.
if (m_state != State::Loading && m_state != State::Done)
return JS::PrimitiveString::create(vm, String {});
// 2. Return the result of getting a text response for this.
return JS::PrimitiveString::create(vm, get_text_response());
}
// 2. If this’s state is not done, then return null.
if (m_state != State::Done)
return JS::js_null();
// 3. If this’s response object is failure, then return null.
if (m_response_object.has<Failure>())
return JS::js_null();
// 4. If this’s response object is non-null, then return it.
if (!m_response_object.has<Empty>())
return m_response_object.get<JS::NonnullGCPtr<JS::Object>>();
// 5. If this’s response type is "arraybuffer",
if (m_response_type == Bindings::XMLHttpRequestResponseType::Arraybuffer) {
// then set this’s response object to a new ArrayBuffer object representing this’s received bytes. If this throws an exception, then set this’s response object to failure and return null.
auto buffer_result = JS::ArrayBuffer::create(realm(), m_received_bytes.size());
if (buffer_result.is_error()) {
m_response_object = Failure();
return JS::js_null();
}
auto buffer = buffer_result.release_value();
buffer->buffer().overwrite(0, m_received_bytes.data(), m_received_bytes.size());
m_response_object = JS::NonnullGCPtr<JS::Object> { buffer };
}
// 6. Otherwise, if this’s response type is "blob", set this’s response object to a new Blob object representing this’s received bytes with type set to the result of get a final MIME type for this.
else if (m_response_type == Bindings::XMLHttpRequestResponseType::Blob) {
auto mime_type_as_string = TRY_OR_THROW_OOM(vm, TRY_OR_THROW_OOM(vm, get_final_mime_type()).serialized());
auto blob_part = FileAPI::Blob::create(realm(), m_received_bytes, move(mime_type_as_string));
auto blob = FileAPI::Blob::create(realm(), Vector<FileAPI::BlobPart> { JS::make_handle(*blob_part) });
m_response_object = JS::NonnullGCPtr<JS::Object> { blob };
}
// 7. Otherwise, if this’s response type is "document", set a document response for this.
else if (m_response_type == Bindings::XMLHttpRequestResponseType::Document) {
set_document_response();
if (m_response_object.has<Empty>())
return JS::js_null();
}
// 8. Otherwise:
else {
// 1. Assert: this’s response type is "json".
// Note: Automatically done by the layers above us.
// 2. If this’s response’s body is null, then return null.
if (!m_response->body())
return JS::js_null();
// 3. Let jsonObject be the result of running parse JSON from bytes on this’s received bytes. If that threw an exception, then return null.
auto json_object_result = Infra::parse_json_bytes_to_javascript_value(realm(), m_received_bytes);
if (json_object_result.is_error())
return JS::js_null();
// 4. Set this’s response object to jsonObject.
m_response_object = JS::NonnullGCPtr<JS::Object> { json_object_result.release_value().as_object() };
}
// 9. Return this’s response object.
return m_response_object.get<JS::NonnullGCPtr<JS::Object>>();
}
// https://xhr.spec.whatwg.org/#text-response
String XMLHttpRequest::get_text_response() const
{
// 1. If xhr’s response’s body is null, then return the empty string.
if (!m_response->body())
return String {};
// 2. Let charset be the result of get a final encoding for xhr.
auto charset = get_final_encoding().release_value_but_fixme_should_propagate_errors();
// 3. If xhr’s response type is the empty string, charset is null, and the result of get a final MIME type for xhr is an XML MIME type,
if (m_response_type == Bindings::XMLHttpRequestResponseType::Empty && !charset.has_value() && get_final_mime_type().release_value_but_fixme_should_propagate_errors().is_xml()) {
// FIXME: then use the rules set forth in the XML specifications to determine the encoding. Let charset be the determined encoding. [XML] [XML-NAMES]
}
// 4. If charset is null, then set charset to UTF-8.
if (!charset.has_value())
charset = "UTF-8"sv;
// 5. Return the result of running decode on xhr’s received bytes using fallback encoding charset.
auto decoder = TextCodec::decoder_for(charset.value());
// If we don't support the decoder yet, let's crash instead of attempting to return something, as the result would be incorrect and create obscure bugs.
VERIFY(decoder.has_value());
return TextCodec::convert_input_to_utf8_using_given_decoder_unless_there_is_a_byte_order_mark(*decoder, m_received_bytes).release_value_but_fixme_should_propagate_errors();
}
// https://xhr.spec.whatwg.org/#document-response
void XMLHttpRequest::set_document_response()
{
// 1. If xhr’s response’s body is null, then return.
if (!m_response->body())
return;
// 2. Let finalMIME be the result of get a final MIME type for xhr.
auto final_mine = MUST(get_final_mime_type());
// 3. If finalMIME is not an HTML MIME type or an XML MIME type, then return.
if (!final_mine.is_html() && !final_mine.is_xml())
return;
// 4. If xhr’s response type is the empty string and finalMIME is an HTML MIME type, then return.
if (m_response_type == Bindings::XMLHttpRequestResponseType::Empty && final_mine.is_html())
return;
// 5. If finalMIME is an HTML MIME type, then:
Optional<StringView> charset;
JS::GCPtr<DOM::Document> document;
if (final_mine.is_html()) {
// 5.1. Let charset be the result of get a final encoding for xhr.
charset = MUST(get_final_encoding());
// 5.2. If charset is null, prescan the first 1024 bytes of xhr’s received bytes and if that does not terminate unsuccessfully then let charset be the return value.
document = DOM::Document::create(realm());
if (!charset.has_value())
if (auto found_charset = HTML::run_prescan_byte_stream_algorithm(*document, m_received_bytes); found_charset.has_value())
charset = MUST(String::from_byte_string(found_charset.value())).bytes_as_string_view();
// 5.3. If charset is null, then set charset to UTF-8.
if (!charset.has_value())
charset = "UTF-8"sv;
// 5.4. Let document be a document that represents the result parsing xhr’s received bytes following the rules set forth in the HTML Standard for an HTML parser with scripting disabled and a known definite encoding charset.
auto parser = HTML::HTMLParser::create(*document, m_received_bytes, charset.value());
parser->run(document->url());
// 5.5. Flag document as an HTML document.
document->set_document_type(DOM::Document::Type::HTML);
}
// 6. Otherwise, let document be a document that represents the result of running the XML parser with XML scripting support disabled on xhr’s received bytes. If that fails (unsupported character encoding, namespace well-formedness error, etc.), then return null.
else {
document = DOM::XMLDocument::create(realm(), m_response->url().value_or({}));
if (!Web::build_xml_document(*document, m_received_bytes, {})) {
m_response_object = Empty {};
return;
}
}
// 7. If charset is null, then set charset to UTF-8.
if (!charset.has_value())
charset = "UTF-8"sv;
// 8. Set document’s encoding to charset.
document->set_encoding(MUST(String::from_utf8(charset.value())));
// 9. Set document’s content type to finalMIME.
document->set_content_type(MUST(final_mine.serialized()));
// 10. Set document’s URL to xhr’s response’s URL.
document->set_url(m_response->url().value_or({}));
// 11. Set document’s origin to xhr’s relevant settings object’s origin.
document->set_origin(HTML::relevant_settings_object(*this).origin());
// 12. Set xhr’s response object to document.
m_response_object = JS::NonnullGCPtr<JS::Object> { *document };
}
// https://xhr.spec.whatwg.org/#final-mime-type
ErrorOr<MimeSniff::MimeType> XMLHttpRequest::get_final_mime_type() const
{
// 1. If xhr’s override MIME type is null, return the result of get a response MIME type for xhr.
if (!m_override_mime_type.has_value())
return get_response_mime_type();
// 2. Return xhr’s override MIME type.
return *m_override_mime_type;
}
// https://xhr.spec.whatwg.org/#response-mime-type
ErrorOr<MimeSniff::MimeType> XMLHttpRequest::get_response_mime_type() const
{
// 1. Let mimeType be the result of extracting a MIME type from xhr’s response’s header list.
auto mime_type = TRY(m_response->header_list()->extract_mime_type());
// 2. If mimeType is failure, then set mimeType to text/xml.
if (!mime_type.has_value())
return MimeSniff::MimeType::create("text"_string, "xml"_string);
// 3. Return mimeType.
return mime_type.release_value();
}
// https://xhr.spec.whatwg.org/#final-charset
ErrorOr<Optional<StringView>> XMLHttpRequest::get_final_encoding() const
{
// 1. Let label be null.
Optional<String> label;
// 2. Let responseMIME be the result of get a response MIME type for xhr.
auto response_mime = TRY(get_response_mime_type());
// 3. If responseMIME’s parameters["charset"] exists, then set label to it.
auto response_mime_charset_it = response_mime.parameters().find("charset"sv);
if (response_mime_charset_it != response_mime.parameters().end())
label = response_mime_charset_it->value;
// 4. If xhr’s override MIME type’s parameters["charset"] exists, then set label to it.
if (m_override_mime_type.has_value()) {
auto override_mime_charset_it = m_override_mime_type->parameters().find("charset"sv);
if (override_mime_charset_it != m_override_mime_type->parameters().end())
label = override_mime_charset_it->value;
}
// 5. If label is null, then return null.
if (!label.has_value())
return OptionalNone {};
// 6. Let encoding be the result of getting an encoding from label.
auto encoding = TextCodec::get_standardized_encoding(label.value());
// 7. If encoding is failure, then return null.
// 8. Return encoding.
return encoding;
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-setrequestheader
WebIDL::ExceptionOr<void> XMLHttpRequest::set_request_header(String const& name_string, String const& value_string)
{
auto& realm = this->realm();
auto& vm = realm.vm();
auto name = name_string.bytes();
auto value = value_string.bytes();
// 1. If this’s state is not opened, then throw an "InvalidStateError" DOMException.
if (m_state != State::Opened)
return WebIDL::InvalidStateError::create(realm, "XHR readyState is not OPENED"_fly_string);
// 2. If this’s send() flag is set, then throw an "InvalidStateError" DOMException.
if (m_send)
return WebIDL::InvalidStateError::create(realm, "XHR send() flag is already set"_fly_string);
// 3. Normalize value.
auto normalized_value = TRY_OR_THROW_OOM(vm, Fetch::Infrastructure::normalize_header_value(value));
// 4. If name is not a header name or value is not a header value, then throw a "SyntaxError" DOMException.
if (!Fetch::Infrastructure::is_header_name(name))
return WebIDL::SyntaxError::create(realm, "Header name contains invalid characters."_fly_string);
if (!Fetch::Infrastructure::is_header_value(value))
return WebIDL::SyntaxError::create(realm, "Header value contains invalid characters."_fly_string);
auto header = Fetch::Infrastructure::Header {
.name = TRY_OR_THROW_OOM(vm, ByteBuffer::copy(name)),
.value = move(normalized_value),
};
// 5. If (name, value) is a forbidden request-header, then return.
if (TRY_OR_THROW_OOM(vm, Fetch::Infrastructure::is_forbidden_request_header(header)))
return {};
// 6. Combine (name, value) in this’s author request headers.
TRY_OR_THROW_OOM(vm, m_author_request_headers->combine(move(header)));
return {};
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-open
WebIDL::ExceptionOr<void> XMLHttpRequest::open(String const& method_string, String const& url)
{
// 7. If the async argument is omitted, set async to true, and set username and password to null.
return open(method_string, url, true, Optional<String> {}, Optional<String> {});
}
WebIDL::ExceptionOr<void> XMLHttpRequest::open(String const& method_string, String const& url, bool async, Optional<String> const& username, Optional<String> const& password)
{
auto method = method_string.bytes();
// 1. If this’s relevant global object is a Window object and its associated Document is not fully active, then throw an "InvalidStateError" DOMException.
if (is<HTML::Window>(HTML::relevant_global_object(*this))) {
auto const& window = static_cast<HTML::Window const&>(HTML::relevant_global_object(*this));
if (!window.associated_document().is_fully_active())
return WebIDL::InvalidStateError::create(realm(), "Invalid state: Window's associated document is not fully active."_fly_string);
}
// 2. If method is not a method, then throw a "SyntaxError" DOMException.
if (!Fetch::Infrastructure::is_method(method))
return WebIDL::SyntaxError::create(realm(), "An invalid or illegal string was specified."_fly_string);
// 3. If method is a forbidden method, then throw a "SecurityError" DOMException.
if (Fetch::Infrastructure::is_forbidden_method(method))
return WebIDL::SecurityError::create(realm(), "Forbidden method, must not be 'CONNECT', 'TRACE', or 'TRACK'"_fly_string);
// 4. Normalize method.
auto normalized_method = TRY_OR_THROW_OOM(vm(), Fetch::Infrastructure::normalize_method(method));
// 5. Let parsedURL be the result of parsing url with this’s relevant settings object’s API base URL and this’s relevant settings object’s API URL character encoding.
// FIXME: Pass in this’s relevant settings object’s API URL character encoding.
auto parsed_url = HTML::relevant_settings_object(*this).api_base_url().complete_url(url);
// 6. If parsedURL is failure, then throw a "SyntaxError" DOMException.
if (!parsed_url.is_valid())
return WebIDL::SyntaxError::create(realm(), "Invalid URL"_fly_string);
// 7. If the async argument is omitted, set async to true, and set username and password to null.
// NOTE: This is handled in the overload lacking the async argument.
// 8. If parsedURL’s host is non-null, then:
if (!parsed_url.host().has<Empty>()) {
// 1. If the username argument is not null, set the username given parsedURL and username.
if (username.has_value())
MUST(parsed_url.set_username(username.value()));
// 2. If the password argument is not null, set the password given parsedURL and password.
if (password.has_value())
MUST(parsed_url.set_password(password.value()));
}
// 9. If async is false, the current global object is a Window object, and either this’s timeout is
// not 0 or this’s response type is not the empty string, then throw an "InvalidAccessError" DOMException.
if (!async
&& is<HTML::Window>(HTML::current_global_object())
&& (m_timeout != 0 || m_response_type != Bindings::XMLHttpRequestResponseType::Empty)) {
return WebIDL::InvalidAccessError::create(realm(), "Synchronous XMLHttpRequests in a Window context do not support timeout or a non-empty responseType"_fly_string);
}
// 10. Terminate this’s fetch controller.
// Spec Note: A fetch can be ongoing at this point.
m_fetch_controller->terminate();
// 11. Set variables associated with the object as follows:
// Unset this’s send() flag.
m_send = false;
// Unset this’s upload listener flag.
m_upload_listener = false;
// Set this’s request method to method.
m_request_method = normalized_method.span();
// Set this’s request URL to parsedURL.
m_request_url = parsed_url;
// Set this’s synchronous flag if async is false; otherwise unset this’s synchronous flag.
m_synchronous = !async;
// Empty this’s author request headers.
m_author_request_headers->clear();
// Set this’s response to a network error.
m_response = Fetch::Infrastructure::Response::network_error(realm().vm(), "Not yet sent"sv);
// Set this’s received bytes to the empty byte sequence.
m_received_bytes = {};
// Set this’s response object to null.
m_response_object = {};
// Spec Note: Override MIME type is not overridden here as the overrideMimeType() method can be invoked before the open() method.
// 12. If this’s state is not opened, then:
if (m_state != State::Opened) {
// 1. Set this’s state to opened.
m_state = State::Opened;
// 2. Fire an event named readystatechange at this.
dispatch_event(DOM::Event::create(realm(), EventNames::readystatechange));
}
return {};
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-send
WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequestBodyInit> body)
{
auto& vm = this->vm();
auto& realm = *vm.current_realm();
// 1. If this’s state is not opened, then throw an "InvalidStateError" DOMException.
if (m_state != State::Opened)
return WebIDL::InvalidStateError::create(realm, "XHR readyState is not OPENED"_fly_string);
// 2. If this’s send() flag is set, then throw an "InvalidStateError" DOMException.
if (m_send)
return WebIDL::InvalidStateError::create(realm, "XHR send() flag is already set"_fly_string);
// 3. If this’s request method is `GET` or `HEAD`, then set body to null.
if (m_request_method.is_one_of("GET"sv, "HEAD"sv))
body = {};
// 4. If body is not null, then:
if (body.has_value()) {
// 1. Let extractedContentType be null.
Optional<ByteBuffer> extracted_content_type;
// 2. If body is a Document, then set this’s request body to body, serialized, converted, and UTF-8 encoded.
if (body->has<JS::Handle<DOM::Document>>()) {
auto string_serialized_document = TRY(body->get<JS::Handle<DOM::Document>>().cell()->serialize_fragment(DOMParsing::RequireWellFormed::No));
m_request_body = TRY(Fetch::Infrastructure::byte_sequence_as_body(realm, string_serialized_document.bytes()));
}
// 3. Otherwise:
else {
// 1. Let bodyWithType be the result of safely extracting body.
auto body_with_type = TRY(Fetch::safely_extract_body(realm, body->downcast<Fetch::BodyInitOrReadableBytes>()));
// 2. Set this’s request body to bodyWithType’s body.
m_request_body = move(body_with_type.body);
// 3. Set extractedContentType to bodyWithType’s type.
extracted_content_type = move(body_with_type.type);
}
// 4. Let originalAuthorContentType be the result of getting `Content-Type` from this’s author request headers.
auto original_author_content_type = TRY_OR_THROW_OOM(vm, m_author_request_headers->get("Content-Type"sv.bytes()));
// 5. If originalAuthorContentType is non-null, then:
if (original_author_content_type.has_value()) {
// 1. If body is a Document or a USVString, then:
if (body->has<JS::Handle<DOM::Document>>() || body->has<String>()) {
// 1. Let contentTypeRecord be the result of parsing originalAuthorContentType.
auto content_type_record = TRY_OR_THROW_OOM(vm, MimeSniff::MimeType::parse(original_author_content_type.value()));
// 2. If contentTypeRecord is not failure, contentTypeRecord’s parameters["charset"] exists, and parameters["charset"] is not an ASCII case-insensitive match for "UTF-8", then:
if (content_type_record.has_value()) {
auto charset_parameter_iterator = content_type_record->parameters().find("charset"sv);
if (charset_parameter_iterator != content_type_record->parameters().end() && !Infra::is_ascii_case_insensitive_match(charset_parameter_iterator->value, "UTF-8"sv)) {
// 1. Set contentTypeRecord’s parameters["charset"] to "UTF-8".
TRY_OR_THROW_OOM(vm, content_type_record->set_parameter("charset"_string, "UTF-8"_string));
// 2. Let newContentTypeSerialized be the result of serializing contentTypeRecord.
auto new_content_type_serialized = TRY_OR_THROW_OOM(vm, content_type_record->serialized());
// 3. Set (`Content-Type`, newContentTypeSerialized) in this’s author request headers.
auto header = TRY_OR_THROW_OOM(vm, Fetch::Infrastructure::Header::from_string_pair("Content-Type"sv, new_content_type_serialized));
TRY_OR_THROW_OOM(vm, m_author_request_headers->set(move(header)));
}
}
}
}
// 6. Otherwise:
else {
if (body->has<JS::Handle<DOM::Document>>()) {
auto document = body->get<JS::Handle<DOM::Document>>();
// NOTE: A document can only be an HTML document or XML document.
// 1. If body is an HTML document, then set (`Content-Type`, `text/html;charset=UTF-8`) in this’s author request headers.
if (document->is_html_document()) {
auto header = TRY_OR_THROW_OOM(vm, Fetch::Infrastructure::Header::from_string_pair("Content-Type"sv, "text/html;charset=UTF-8"sv));
TRY_OR_THROW_OOM(vm, m_author_request_headers->set(move(header)));
}
// 2. Otherwise, if body is an XML document, set (`Content-Type`, `application/xml;charset=UTF-8`) in this’s author request headers.
else if (document->is_xml_document()) {
auto header = TRY_OR_THROW_OOM(vm, Fetch::Infrastructure::Header::from_string_pair("Content-Type"sv, "application/xml;charset=UTF-8"sv));
TRY_OR_THROW_OOM(vm, m_author_request_headers->set(move(header)));
} else {
VERIFY_NOT_REACHED();
}
}
// 3. Otherwise, if extractedContentType is not null, set (`Content-Type`, extractedContentType) in this’s author request headers.
else if (extracted_content_type.has_value()) {
auto header = TRY_OR_THROW_OOM(vm, Fetch::Infrastructure::Header::from_string_pair("Content-Type"sv, extracted_content_type.value()));
TRY_OR_THROW_OOM(vm, m_author_request_headers->set(move(header)));
}
}
}
// 5. If one or more event listeners are registered on this’s upload object, then set this’s upload listener flag.
m_upload_listener = m_upload_object->has_event_listeners();
// 6. Let req be a new request, initialized as follows:
auto request = Fetch::Infrastructure::Request::create(vm);
// method
// This’s request method.
request->set_method(TRY_OR_THROW_OOM(vm, ByteBuffer::copy(m_request_method.bytes())));
// URL
// This’s request URL.
request->set_url(m_request_url);
// header list
// This’s author request headers.
request->set_header_list(m_author_request_headers);
// unsafe-request flag
// Set.
request->set_unsafe_request(true);
// body
// This’s request body.
if (m_request_body)
request->set_body(JS::NonnullGCPtr { *m_request_body });
// client
// This’s relevant settings object.
request->set_client(&HTML::relevant_settings_object(*this));
// mode
// "cors".
request->set_mode(Fetch::Infrastructure::Request::Mode::CORS);
// use-CORS-preflight flag
// Set if this’s upload listener flag is set.
request->set_use_cors_preflight(m_upload_listener);
// credentials mode
// If this’s cross-origin credentials is true, then "include"; otherwise "same-origin".
request->set_credentials_mode(m_cross_origin_credentials ? Fetch::Infrastructure::Request::CredentialsMode::Include : Fetch::Infrastructure::Request::CredentialsMode::SameOrigin);
// use-URL-credentials flag
// Set if this’s request URL includes credentials.
request->set_use_url_credentials(m_request_url.includes_credentials());
// initiator type
// "xmlhttprequest".
request->set_initiator_type(Fetch::Infrastructure::Request::InitiatorType::XMLHttpRequest);
// 7. Unset this’s upload complete flag.
m_upload_complete = false;
// 8. Unset this’s timed out flag.
m_timed_out = false;
// 9. If req’s body is null, then set this’s upload complete flag.
// NOTE: req's body is always m_request_body here, see step 6.
if (!m_request_body)
m_upload_complete = true;
// 10. Set this’s send() flag.
m_send = true;
dbgln_if(SPAM_DEBUG, "{}XHR send from {} to {}", m_synchronous ? "\033[33;1mSynchronous\033[0m " : "", HTML::relevant_settings_object(*this).creation_url, m_request_url);
// 11. If this’s synchronous flag is unset, then:
if (!m_synchronous) {
// 1. Fire a progress event named loadstart at this with 0 and 0.
fire_progress_event(*this, EventNames::loadstart, 0, 0);
// 2. Let requestBodyTransmitted be 0.
// NOTE: This is kept on the XHR object itself instead of the stack, as we cannot capture references to stack variables in an async context.
m_request_body_transmitted = 0;
// 3. Let requestBodyLength be req’s body’s length, if req’s body is non-null; otherwise 0.
// NOTE: req's body is always m_request_body here, see step 6.
// 4. Assert: requestBodyLength is an integer.
// NOTE: This is done to provide a better assertion failure message, whereas below the message would be "m_has_value"
if (m_request_body)
VERIFY(m_request_body->length().has_value());
// NOTE: This is const to allow the callback functions to take a copy of it and know it won't change.
auto const request_body_length = m_request_body ? m_request_body->length().value() : 0;
// 5. If this’s upload complete flag is unset and this’s upload listener flag is set, then fire a progress event named loadstart at this’s upload object with requestBodyTransmitted and requestBodyLength.
if (!m_upload_complete && m_upload_listener)
fire_progress_event(m_upload_object, EventNames::loadstart, m_request_body_transmitted, request_body_length);
// 6. If this’s state is not opened or this’s send() flag is unset, then return.
if (m_state != State::Opened || !m_send)
return {};
// 7. Let processRequestBodyChunkLength, given a bytesLength, be these steps:
// NOTE: request_body_length is captured by copy as to not UAF it when we leave `send()` and the callback gets called.
// NOTE: `this` is kept alive by FetchAlgorithms using JS::SafeFunction.
auto process_request_body_chunk_length = [this, request_body_length](u64 bytes_length) {
// 1. Increase requestBodyTransmitted by bytesLength.
m_request_body_transmitted += bytes_length;
// FIXME: 2. If not roughly 50ms have passed since these steps were last invoked, then return.
// 3. If this’s upload listener flag is set, then fire a progress event named progress at this’s upload object with requestBodyTransmitted and requestBodyLength.
if (m_upload_listener)
fire_progress_event(m_upload_object, EventNames::progress, m_request_body_transmitted, request_body_length);
};
// 8. Let processRequestEndOfBody be these steps:
// NOTE: request_body_length is captured by copy as to not UAF it when we leave `send()` and the callback gets called.
// NOTE: `this` is kept alive by FetchAlgorithms using JS::SafeFunction.
auto process_request_end_of_body = [this, request_body_length]() {
// 1. Set this’s upload complete flag.
m_upload_complete = true;
// 2. If this’s upload listener flag is unset, then return.
if (!m_upload_listener)
return;
// 3. Fire a progress event named progress at this’s upload object with requestBodyTransmitted and requestBodyLength.
fire_progress_event(m_upload_object, EventNames::progress, m_request_body_transmitted, request_body_length);
// 4. Fire a progress event named load at this’s upload object with requestBodyTransmitted and requestBodyLength.
fire_progress_event(m_upload_object, EventNames::load, m_request_body_transmitted, request_body_length);
// 5. Fire a progress event named loadend at this’s upload object with requestBodyTransmitted and requestBodyLength.
fire_progress_event(m_upload_object, EventNames::loadend, m_request_body_transmitted, request_body_length);
};
// 9. Let processResponse, given a response, be these steps:
// NOTE: `this` is kept alive by FetchAlgorithms using JS::SafeFunction.
auto process_response = [this](JS::NonnullGCPtr<Fetch::Infrastructure::Response> response) {
// 1. Set this’s response to response.
m_response = response;
// 2. Handle errors for this.
// NOTE: This cannot throw, as `handle_errors` only throws in a synchronous context.
// FIXME: However, we can receive allocation failures, but we can't propagate them anywhere currently.
handle_errors().release_value_but_fixme_should_propagate_errors();
// 3. If this’s response is a network error, then return.
if (m_response->is_network_error())
return;
// 4. Set this’s state to headers received.
m_state = State::HeadersReceived;
// 5. Fire an event named readystatechange at this.
// FIXME: We're in an async context, so we can't propagate the error anywhere.
dispatch_event(*DOM::Event::create(this->realm(), EventNames::readystatechange));
// 6. If this’s state is not headers received, then return.
if (m_state != State::HeadersReceived)
return;
// 7. If this’s response’s body is null, then run handle response end-of-body for this and return.
if (!m_response->body()) {
// NOTE: This cannot throw, as `handle_response_end_of_body` only throws in a synchronous context.
// FIXME: However, we can receive allocation failures, but we can't propagate them anywhere currently.
handle_response_end_of_body().release_value_but_fixme_should_propagate_errors();
return;
}
// 8. Let length be the result of extracting a length from this’s response’s header list.
// FIXME: We're in an async context, so we can't propagate the error anywhere.
auto length = m_response->header_list()->extract_length().release_value_but_fixme_should_propagate_errors();
// 9. If length is not an integer, then set it to 0.
if (!length.has<u64>())
length = 0;
// FIXME: We can't implement these steps yet, as we don't fully implement the Streams standard.
// 10. Let processBodyChunk given bytes be these steps:
// 1. Append bytes to this’s received bytes.
// 2. If not roughly 50ms have passed since these steps were last invoked, then return.
// 3. If this’s state is headers received, then set this’s state to loading.
// 4. Fire an event named readystatechange at this.
// Spec Note: Web compatibility is the reason readystatechange fires more often than this’s state changes.
// 5. Fire a progress event named progress at this with this’s received bytes’s length and length.
// 11. Let processEndOfBody be this step: run handle response end-of-body for this.
// 12. Let processBodyError be these steps:
// 1. Set this’s response to a network error.
// 2. Run handle errors for this.
// 13. Incrementally read this’s response’s body, given processBodyChunk, processEndOfBody, processBodyError, and this’s relevant global object.
};
// FIXME: Remove this once we implement the Streams standard. See above.
// NOTE: `this` is kept alive by FetchAlgorithms using JS::SafeFunction.
auto process_response_consume_body = [this](JS::NonnullGCPtr<Fetch::Infrastructure::Response>, Variant<Empty, Fetch::Infrastructure::FetchAlgorithms::ConsumeBodyFailureTag, ByteBuffer> null_or_failure_or_bytes) {
// NOTE: `response` is not used here as `process_response` is called before `process_response_consume_body` and thus `m_response` is already set up.
if (null_or_failure_or_bytes.has<ByteBuffer>()) {
// NOTE: We are not in a context where we can throw if this fails due to OOM.
m_received_bytes.append(null_or_failure_or_bytes.get<ByteBuffer>());
}
// NOTE: This cannot throw, as `handle_response_end_of_body` only throws in a synchronous context.
// FIXME: However, we can receive allocation failures, but we can't propagate them anywhere currently.
handle_response_end_of_body().release_value_but_fixme_should_propagate_errors();
};
// 10. Set this’s fetch controller to the result of fetching req with processRequestBodyChunkLength set to processRequestBodyChunkLength, processRequestEndOfBody set to processRequestEndOfBody, and processResponse set to processResponse.
m_fetch_controller = TRY(Fetch::Fetching::fetch(
realm,
request,
Fetch::Infrastructure::FetchAlgorithms::create(vm,
{
.process_request_body_chunk_length = move(process_request_body_chunk_length),
.process_request_end_of_body = move(process_request_end_of_body),
.process_early_hints_response = {},
.process_response = move(process_response),
.process_response_end_of_body = {},
.process_response_consume_body = move(process_response_consume_body), // FIXME: Set this to null once we implement the Streams standard. See above.
})));
// 11. Let now be the present time.
// 12. Run these steps in parallel:
// 1. Wait until either req’s done flag is set or this’s timeout is not 0 and this’s timeout milliseconds have passed since now.
// 2. If req’s done flag is unset, then set this’s timed out flag and terminate this’s fetch controller.
if (m_timeout != 0) {
auto timer = Platform::Timer::create_single_shot(m_timeout, nullptr);
// NOTE: `timer` is kept alive by copying the NNRP into the lambda, incrementing its ref-count.
// NOTE: `this` and `request` is kept alive by Platform::Timer using JS::SafeFunction.
timer->on_timeout = [this, request, timer]() {
if (!request->done()) {
m_timed_out = true;
m_fetch_controller->terminate();
}
};
timer->start();
}
} else {
// 1. Let processedResponse be false.
bool processed_response = false;
// 2. Let processResponseConsumeBody, given a response and nullOrFailureOrBytes, be these steps:
auto process_response_consume_body = [this, &processed_response](JS::NonnullGCPtr<Fetch::Infrastructure::Response> response, Variant<Empty, Fetch::Infrastructure::FetchAlgorithms::ConsumeBodyFailureTag, ByteBuffer> null_or_failure_or_bytes) {
// 1. If nullOrFailureOrBytes is not failure, then set this’s response to response.
if (!null_or_failure_or_bytes.has<Fetch::Infrastructure::FetchAlgorithms::ConsumeBodyFailureTag>())
m_response = response;
// 2. If nullOrFailureOrBytes is a byte sequence, then append nullOrFailureOrBytes to this’s received bytes.
if (null_or_failure_or_bytes.has<ByteBuffer>()) {
// NOTE: We are not in a context where we can throw if this fails due to OOM.
m_received_bytes.append(null_or_failure_or_bytes.get<ByteBuffer>());
}
// 3. Set processedResponse to true.
processed_response = true;
};
// 3. Set this’s fetch controller to the result of fetching req with processResponseConsumeBody set to processResponseConsumeBody and useParallelQueue set to true.
m_fetch_controller = TRY(Fetch::Fetching::fetch(
realm,
request,
Fetch::Infrastructure::FetchAlgorithms::create(vm,
{
.process_request_body_chunk_length = {},
.process_request_end_of_body = {},
.process_early_hints_response = {},
.process_response = {},
.process_response_end_of_body = {},
.process_response_consume_body = move(process_response_consume_body),
}),
Fetch::Fetching::UseParallelQueue::Yes));
// 4. Let now be the present time.
// 5. Pause until either processedResponse is true or this’s timeout is not 0 and this’s timeout milliseconds have passed since now.
bool did_time_out = false;
if (m_timeout != 0) {
auto timer = Platform::Timer::create_single_shot(m_timeout, nullptr);
// NOTE: `timer` is kept alive by copying the NNRP into the lambda, incrementing its ref-count.
timer->on_timeout = [timer, &did_time_out]() {
did_time_out = true;
};
timer->start();
}
// FIXME: This is not exactly correct, as it allows the HTML event loop to continue executing tasks.
Platform::EventLoopPlugin::the().spin_until([&]() {
return processed_response || did_time_out;
});
// 6. If processedResponse is false, then set this’s timed out flag and terminate this’s fetch controller.
if (!processed_response) {
m_timed_out = true;
m_fetch_controller->terminate();
}
// FIXME: 7. Report timing for this’s fetch controller given the current global object.
// We cannot do this for responses that have a body yet, as we do not setup the stream that then calls processResponseEndOfBody in `fetch_response_handover`.
// 8. Run handle response end-of-body for this.
TRY(handle_response_end_of_body());
}
return {};
}
WebIDL::CallbackType* XMLHttpRequest::onreadystatechange()
{
return event_handler_attribute(Web::XHR::EventNames::readystatechange);
}
void XMLHttpRequest::set_onreadystatechange(WebIDL::CallbackType* value)
{
set_event_handler_attribute(Web::XHR::EventNames::readystatechange, value);
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-getresponseheader
WebIDL::ExceptionOr<Optional<String>> XMLHttpRequest::get_response_header(String const& name) const
{
auto& vm = this->vm();
// The getResponseHeader(name) method steps are to return the result of getting name from this’s response’s header list.
auto header_bytes = TRY_OR_THROW_OOM(vm, m_response->header_list()->get(name.bytes()));
return header_bytes.has_value() ? TRY_OR_THROW_OOM(vm, String::from_utf8(*header_bytes)) : Optional<String> {};
}
// https://xhr.spec.whatwg.org/#legacy-uppercased-byte-less-than
static ErrorOr<bool> is_legacy_uppercased_byte_less_than(ReadonlyBytes a, ReadonlyBytes b)
{
// 1. Let A be a, byte-uppercased.
auto uppercased_a = TRY(ByteBuffer::copy(a));
Infra::byte_uppercase(uppercased_a);
// 2. Let B be b, byte-uppercased.
auto uppercased_b = TRY(ByteBuffer::copy(b));
Infra::byte_uppercase(uppercased_b);
// 3. Return A is byte less than B.
return Infra::is_byte_less_than(uppercased_a, uppercased_b);
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-getallresponseheaders
WebIDL::ExceptionOr<String> XMLHttpRequest::get_all_response_headers() const
{
auto& vm = this->vm();
// 1. Let output be an empty byte sequence.
ByteBuffer output;
// 2. Let initialHeaders be the result of running sort and combine with this’s response’s header list.
auto initial_headers = TRY_OR_THROW_OOM(vm, m_response->header_list()->sort_and_combine());
// 3. Let headers be the result of sorting initialHeaders in ascending order, with a being less than b if a’s name is legacy-uppercased-byte less than b’s name.
// Spec Note: Unfortunately, this is needed for compatibility with deployed content.
// NOTE: quick_sort mutates the collection instead of returning a sorted copy.
quick_sort(initial_headers, [](Fetch::Infrastructure::Header const& a, Fetch::Infrastructure::Header const& b) {
// FIXME: We are not in a context where we can throw from OOM.
return is_legacy_uppercased_byte_less_than(a.name, b.name).release_value_but_fixme_should_propagate_errors();
});
// 4. For each header in headers, append header’s name, followed by a 0x3A 0x20 byte pair, followed by header’s value, followed by a 0x0D 0x0A byte pair, to output.
for (auto const& header : initial_headers) {
TRY_OR_THROW_OOM(vm, output.try_append(header.name));
TRY_OR_THROW_OOM(vm, output.try_append(0x3A)); // ':'
TRY_OR_THROW_OOM(vm, output.try_append(0x20)); // ' '
TRY_OR_THROW_OOM(vm, output.try_append(header.value));
TRY_OR_THROW_OOM(vm, output.try_append(0x0D)); // '\r'
TRY_OR_THROW_OOM(vm, output.try_append(0x0A)); // '\n'
}
// 5. Return output.
return TRY_OR_THROW_OOM(vm, String::from_utf8(output));
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-overridemimetype
WebIDL::ExceptionOr<void> XMLHttpRequest::override_mime_type(String const& mime)
{
auto& vm = this->vm();
// 1. If this’s state is loading or done, then throw an "InvalidStateError" DOMException.
if (m_state == State::Loading || m_state == State::Done)
return WebIDL::InvalidStateError::create(realm(), "Cannot override MIME type when state is Loading or Done."_fly_string);
// 2. Set this’s override MIME type to the result of parsing mime.
m_override_mime_type = TRY_OR_THROW_OOM(vm, MimeSniff::MimeType::parse(mime));
// 3. If this’s override MIME type is failure, then set this’s override MIME type to application/octet-stream.
if (!m_override_mime_type.has_value())
m_override_mime_type = TRY_OR_THROW_OOM(vm, MimeSniff::MimeType::create("application"_string, "octet-stream"_string));
return {};
}
// https://xhr.spec.whatwg.org/#ref-for-dom-xmlhttprequest-timeout%E2%91%A2
WebIDL::ExceptionOr<void> XMLHttpRequest::set_timeout(u32 timeout)
{
// 1. If the current global object is a Window object and this’s synchronous flag is set,
// then throw an "InvalidAccessError" DOMException.
if (is<HTML::Window>(HTML::current_global_object()) && m_synchronous)
return WebIDL::InvalidAccessError::create(realm(), "Use of XMLHttpRequest's timeout attribute is not supported in the synchronous mode in window context."_fly_string);
// 2. Set this’s timeout to the given value.
m_timeout = timeout;
return {};
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-timeout
u32 XMLHttpRequest::timeout() const { return m_timeout; }
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials
bool XMLHttpRequest::with_credentials() const
{
// The withCredentials getter steps are to return this’s cross-origin credentials.
return m_cross_origin_credentials;
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-withcredentials
WebIDL::ExceptionOr<void> XMLHttpRequest::set_with_credentials(bool with_credentials)
{
auto& realm = this->realm();
// 1. If this’s state is not unsent or opened, then throw an "InvalidStateError" DOMException.
if (m_state != State::Unsent && m_state != State::Opened)
return WebIDL::InvalidStateError::create(realm, "XHR readyState is not UNSENT or OPENED"_fly_string);
// 2. If this’s send() flag is set, then throw an "InvalidStateError" DOMException.
if (m_send)
return WebIDL::InvalidStateError::create(realm, "XHR send() flag is already set"_fly_string);
// 3. Set this’s cross-origin credentials to the given value.
m_cross_origin_credentials = with_credentials;
return {};
}
// https://xhr.spec.whatwg.org/#garbage-collection
bool XMLHttpRequest::must_survive_garbage_collection() const
{
// An XMLHttpRequest object must not be garbage collected
// if its state is either opened with the send() flag set, headers received, or loading,
// and it has one or more event listeners registered whose type is one of
// readystatechange, progress, abort, error, load, timeout, and loadend.
if ((m_state == State::Opened && m_send)
|| m_state == State::HeadersReceived
|| m_state == State::Loading) {
if (has_event_listener(EventNames::readystatechange))
return true;
if (has_event_listener(EventNames::progress))
return true;
if (has_event_listener(EventNames::abort))
return true;
if (has_event_listener(EventNames::error))
return true;
if (has_event_listener(EventNames::load))
return true;
if (has_event_listener(EventNames::timeout))
return true;
if (has_event_listener(EventNames::loadend))
return true;
}
// FIXME: If an XMLHttpRequest object is garbage collected while its connection is still open,
// the user agent must terminate the XMLHttpRequest object’s fetch controller.
// NOTE: This would go in XMLHttpRequest::finalize().
return false;
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-abort
void XMLHttpRequest::abort()
{
// 1. Abort this’s fetch controller.
m_fetch_controller->abort(realm(), {});
// 2. If this’s state is opened with this’s send() flag set, headers received, or loading, then run the request error steps for this and abort.
if ((m_state == State::Opened || m_state == State::HeadersReceived || m_state == State::Loading) && m_send) {
// NOTE: This cannot throw as we don't pass in an exception. XHR::abort cannot be reached in a synchronous context where the state matches above.
// This is because it pauses inside XHR::send until the request is done or times out and then immediately calls `handle_response_end_of_body`
// which will always set `m_state` to `Done`.
MUST(request_error_steps(EventNames::abort));
}
// 3. If this’s state is done, then set this’s state to unsent and this’s response to a network error.
// Spec Note: No readystatechange event is dispatched.
if (m_state == State::Done) {
m_state = State::Unsent;
m_response = Fetch::Infrastructure::Response::network_error(vm(), "Not yet sent"sv);
}
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-upload
JS::NonnullGCPtr<XMLHttpRequestUpload> XMLHttpRequest::upload() const
{
// The upload getter steps are to return this’s upload object.
return m_upload_object;
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-status
Fetch::Infrastructure::Status XMLHttpRequest::status() const
{
// The status getter steps are to return this’s response’s status.
return m_response->status();
}
// https://xhr.spec.whatwg.org/#dom-xmlhttprequest-statustext
WebIDL::ExceptionOr<String> XMLHttpRequest::status_text() const
{
auto& vm = this->vm();
// The statusText getter steps are to return this’s response’s status message.
return TRY_OR_THROW_OOM(vm, String::from_utf8(m_response->status_message()));
}
// https://xhr.spec.whatwg.org/#handle-response-end-of-body
WebIDL::ExceptionOr<void> XMLHttpRequest::handle_response_end_of_body()
{
auto& vm = this->vm();
auto& realm = this->realm();
// 1. Handle errors for xhr.
TRY(handle_errors());
// 2. If xhr’s response is a network error, then return.
if (m_response->is_network_error())
return {};
// 3. Let transmitted be xhr’s received bytes’s length.
auto transmitted = m_received_bytes.size();
// 4. Let length be the result of extracting a length from this’s response’s header list.
auto maybe_length = TRY_OR_THROW_OOM(vm, m_response->header_list()->extract_length());
// 5. If length is not an integer, then set it to 0.
if (!maybe_length.has<u64>())
maybe_length = 0;
auto length = maybe_length.get<u64>();
// 6. If xhr’s synchronous flag is unset, then fire a progress event named progress at xhr with transmitted and length.
if (!m_synchronous)
fire_progress_event(*this, EventNames::progress, transmitted, length);
// 7. Set xhr’s state to done.
m_state = State::Done;
// 8. Unset xhr’s send() flag.
m_send = false;
// 9. Fire an event named readystatechange at xhr.
// FIXME: If we're in an async context, this will propagate to a callback context which can't propagate it anywhere else and does not expect this to fail.
dispatch_event(*DOM::Event::create(realm, EventNames::readystatechange));
// 10. Fire a progress event named load at xhr with transmitted and length.
fire_progress_event(*this, EventNames::load, transmitted, length);
// 11. Fire a progress event named loadend at xhr with transmitted and length.
fire_progress_event(*this, EventNames::loadend, transmitted, length);
return {};
}
// https://xhr.spec.whatwg.org/#handle-errors
WebIDL::ExceptionOr<void> XMLHttpRequest::handle_errors()
{
// 1. If xhr’s send() flag is unset, then return.
if (!m_send)
return {};
// 2. If xhr’s timed out flag is set, then run the request error steps for xhr, timeout, and "TimeoutError" DOMException.
if (m_timed_out)
return TRY(request_error_steps(EventNames::timeout, WebIDL::TimeoutError::create(realm(), "Timed out"_fly_string)));
// 3. Otherwise, if xhr’s response’s aborted flag is set, run the request error steps for xhr, abort, and "AbortError" DOMException.
if (m_response->aborted())
return TRY(request_error_steps(EventNames::abort, WebIDL::AbortError::create(realm(), "Aborted"_fly_string)));
// 4. Otherwise, if xhr’s response is a network error, then run the request error steps for xhr, error, and "NetworkError" DOMException.
if (m_response->is_network_error())
return TRY(request_error_steps(EventNames::error, WebIDL::NetworkError::create(realm(), "Network error"_fly_string)));
return {};
}
JS::ThrowCompletionOr<void> XMLHttpRequest::request_error_steps(FlyString const& event_name, JS::GCPtr<WebIDL::DOMException> exception)
{
// 1. Set xhr’s state to done.
m_state = State::Done;
// 2. Unset xhr’s send() flag.
m_send = false;
// 3. Set xhr’s response to a network error.
m_response = Fetch::Infrastructure::Response::network_error(realm().vm(), "Failed to load"sv);
// 4. If xhr’s synchronous flag is set, then throw exception.
if (m_synchronous) {
VERIFY(exception);
return JS::throw_completion(exception.ptr());
}
// 5. Fire an event named readystatechange at xhr.
// FIXME: Since we're in an async context, this will propagate to a callback context which can't propagate it anywhere else and does not expect this to fail.
dispatch_event(*DOM::Event::create(realm(), EventNames::readystatechange));
// 6. If xhr’s upload complete flag is unset, then:
if (!m_upload_complete) {
// 1. Set xhr’s upload complete flag.
m_upload_complete = true;
// 2. If xhr’s upload listener flag is set, then:
if (m_upload_listener) {
// 1. Fire a progress event named event at xhr’s upload object with 0 and 0.
fire_progress_event(m_upload_object, event_name, 0, 0);
// 2. Fire a progress event named loadend at xhr’s upload object with 0 and 0.
fire_progress_event(m_upload_object, EventNames::loadend, 0, 0);
}
}
// 7. Fire a progress event named event at xhr with 0 and 0.
fire_progress_event(*this, event_name, 0, 0);
// 8. Fire a progress event named loadend at xhr with 0 and 0.
fire_progress_event(*this, EventNames::loadend, 0, 0);
return {};
}
}
Reference in New Issue View Git Blame Copy Permalink