/* * Copyright (c) 2020-2023, Andreas Kling * Copyright (c) 2021-2023, Linus Groh * Copyright (c) 2022-2023, Luke Wilde * Copyright (c) 2022, Ali Mohammad Pur * Copyright (c) 2022-2023, Kenneth Myhra * * SPDX-License-Identifier: BSD-2-Clause */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace Web::XHR { WebIDL::ExceptionOr> XMLHttpRequest::construct_impl(JS::Realm& realm) { auto upload_object = realm.heap().allocate(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(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); set_prototype(&Bindings::ensure_web_prototype(realm, "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>()) 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 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> 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()); // 4. If this’s response object is non-null, then return it. if (!m_response_object.has()) return &verify_cast(*m_response_object.get>()); // 5. Set a document response for this. set_document_response(); // 6. Return this’s response object. if (m_response_object.has()) return nullptr; return &verify_cast(*m_response_object.get>()); } // https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsetype WebIDL::ExceptionOr 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::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::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 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()) return JS::js_null(); // 4. If this’s response object is non-null, then return it. if (!m_response_object.has()) return m_response_object.get>(); // 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 { 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 { JS::make_handle(*blob_part) }); m_response_object = JS::NonnullGCPtr { 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()) 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 { json_object_result.release_value().as_object() }; } // 9. Return this’s response object. return m_response_object.get>(); } // 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 charset; JS::GCPtr 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_deprecated_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 { *document }; } // https://xhr.spec.whatwg.org/#final-mime-type ErrorOr 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 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> XMLHttpRequest::get_final_encoding() const { // 1. Let label be null. Optional 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 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 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 {}, Optional {}); } WebIDL::ExceptionOr XMLHttpRequest::open(String const& method_string, String const& url, bool async, Optional const& username, Optional 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::relevant_global_object(*this))) { auto const& window = static_cast(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()) { // 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::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 XMLHttpRequest::send(Optional 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 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>()) { // FIXME: Perform USVString conversion and UTF-8 encoding. auto string_serialized_document = TRY(body->get>().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())); // 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>() || body->has()) { // 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>()) { auto document = body->get>(); // 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("{}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 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()) 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, Variant 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()) { // 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()); } // 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 response, Variant 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()) 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()) { // 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()); } // 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> 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 {}; } // https://xhr.spec.whatwg.org/#legacy-uppercased-byte-less-than static ErrorOr 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 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 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 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::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 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 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 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 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()) maybe_length = 0; auto length = maybe_length.get(); // 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 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 XMLHttpRequest::request_error_steps(FlyString const& event_name, JS::GCPtr 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 {}; } }