dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / loader / resource_loader_3.lucb
#==============================================================================================
#
# resource_loader_3 - ResourceLoader::load and its network requests
#
# DESCRIPTION:
# Port of Libraries/LibWeb/Loader/ResourceLoader.cpp (lines 354-522): load, which
# dispatches on the URL's scheme, and the network request's start, response headers and
# finish. load's lambdas share one capture struct (ResourceLoaderLoad), made in managed
# memory, holding the copy of the LoadRequest the C++ lambdas capture and the three
# callbacks (GC::Root in C++: the struct's scan keeps them).
#
# Copyright (c) 2018-2024, Andreas Kling <andreas@ladybird.org>
# Copyright (c) 2022, Dex♪ <dexes.ttp@gmail.com>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: load ====================================================================================
## The captures of ResourceLoader::load's lambdas: `this`, the request (by value), the callbacks, and for a network
## load the protocol request and its id.
struct ResourceLoaderLoad:
var this: ResourceLoader*
var request: LoadRequest
var on_headers_received: gc.Function3[const HttpHeaderList*, u32?, const (ak.String?)*, unit]*
var on_data_received: gc.Function1[const u8[], unit]*
var on_complete: gc.Function3[bool, const RequestsRequestTimingInfo*, ak.StringView?, unit]*
var protocol_request: RequestsRequest*?
var request_id: u64
## `on_headers_received->function()(response_headers, status_code, reason_phrase)`.
func headers_received(response_headers: const HttpHeaderList*, status_code: u32?, reason_phrase: ak.String?):
let phrase = reason_phrase
ak.function3_call(&self.on_headers_received.function, response_headers, status_code, &phrase)
## `on_complete->function()(success, timing_info, error_message)`.
func complete(success: bool, timing_info: RequestsRequestTimingInfo, error_message: ak.StringView?):
ak.function3_call(&self.on_complete.function, success, &timing_info, error_message)
## The about: callback: the page's bytes.
static func about_loaded(context: void*?, data: const u8[], timing_info: const RequestsRequestTimingInfo*, response_headers: const HttpHeaderList*):
let captures = (ResourceLoaderLoad*)(context else trap("load: no captures"))
log_success(&captures.request)
captures.headers_received(response_headers, none, none)
ak.function1_call(&captures.on_data_received.function, data)
captures.complete(true, *timing_info, none)
## The resource: on_resource callback.
static func resource_loaded(context: void*?, load_result: const ResourceLoaderFileLoadResult*):
let captures = (ResourceLoaderLoad*)(context else trap("load: no captures"))
captures.headers_received(load_result.response_headers, none, none)
ak.function1_call(&captures.on_data_received.function, load_result.data)
captures.complete(true, load_result.timing_info, none)
## The resource: on_error callback.
static func resource_failed(context: void*?, message: ak.ByteString):
let captures = (ResourceLoaderLoad*)(context else trap("load: no captures"))
let fixme_implement_timing_info = RequestsRequestTimingInfo()
captures.complete(false, fixme_implement_timing_info, ak.byte_string_view(&message))
## The file: on_file callback.
static func file_loaded(context: void*?, load_result: const ResourceLoaderFileLoadResult*):
let captures = (ResourceLoaderLoad*)(context else trap("load: no captures"))
log_success(&captures.request)
captures.headers_received(load_result.response_headers, none, none)
ak.function1_call(&captures.on_data_received.function, load_result.data)
captures.complete(true, load_result.timing_info, none)
## The file: on_error callback.
static func file_failed(context: void*?, message: ak.ByteString):
let captures = (ResourceLoaderLoad*)(context else trap("load: no captures"))
log_failure(&captures.request, ak.byte_string_view(&message))
captures.complete(false, RequestsRequestTimingInfo(), ak.byte_string_view(&message))
## protocol_headers_received.
static func protocol_headers_received(context: void*?, response_headers: HttpHeaderList*, status_code: u32?, reason_phrase: ak.String?):
let captures = (ResourceLoaderLoad*)(context else trap("load: no captures"))
resource_loader_handle_network_response_headers(captures.this, &captures.request, response_headers)
if let page = load_request_page(&captures.request):
page_client_page_did_receive_network_response_headers(page_client(page), captures.request_id, status_code else 0, reason_phrase,
*http_header_list_headers(response_headers))
captures.headers_received(response_headers, status_code, reason_phrase)
## protocol_data_received.
static func protocol_data_received(context: void*?, data: const u8[]):
let captures = (ResourceLoaderLoad*)(context else trap("load: no captures"))
if let page = load_request_page(&captures.request):
page_client_page_did_receive_network_response_body(page_client(page), captures.request_id, data)
ak.function1_call(&captures.on_data_received.function, data)
## protocol_complete.
static func protocol_complete(context: void*?, total_size: u64, timing_info: RequestsRequestTimingInfo, network_error: RequestsNetworkError?):
let captures = (ResourceLoaderLoad*)(context else trap("load: no captures"))
let protocol_request = captures.protocol_request else trap("VERIFY: a network load's request")
resource_loader_finish_network_request(captures.this, protocol_request)
if let page = load_request_page(&captures.request):
page_client_page_did_finish_network_request(page_client(page), requests_request_id(protocol_request), total_size, timing_info, network_error)
if let failure = network_error:
var error_description = ak.string_builder_new()
ak.string_builder_append(&error_description, "Request finished with error: ")
ak.string_builder_append_string_view(&error_description, requests_network_error_to_string(failure))
log_failure(&captures.request, ak.string_builder_string_view(&error_description))
captures.complete(false, timing_info, ak.string_builder_string_view(&error_description))
else:
log_success(&captures.request)
captures.complete(true, timing_info, none)
## `ByteString::formatted("Protocol not implemented: {}", url.scheme())`.
func resource_loader_not_implemented_error(url: const web_url.Url*) -> ak.ByteString:
let scheme = web_url.url_scheme(url)
var builder = ak.string_builder_new()
ak.string_builder_append(&builder, "Protocol not implemented: ")
ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&scheme))
return ak.string_builder_to_byte_string(&builder)
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:354 Web::ResourceLoader::load.
pub func resource_loader_load(this: ResourceLoader*, request: LoadRequest*, on_headers_received: gc.Function3[const HttpHeaderList*, u32?, const (ak.String?)*, unit]*?,
on_data_received: gc.Function1[const u8[], unit]*?, on_complete: gc.Function3[bool, const RequestsRequestTimingInfo*, ak.StringView?, unit]*?) -> RequestsRequest*?:
let url = load_request_url(request) else trap("VERIFY: a load request's URL")
log_request_start(request)
load_request_start_timer(request)
let captures = new ResourceLoaderLoad(this = this, request = *request, on_headers_received = on_headers_received else trap("VERIFY: on_headers_received"),
on_data_received = on_data_received else trap("VERIFY: on_data_received"),
on_complete = on_complete else trap("VERIFY: on_complete"), protocol_request = none, request_id = 0) else trap("out of memory")
if should_block_request(request):
captures.complete(false, RequestsRequestTimingInfo(), ak.sv("Request was blocked"))
return none
let scheme = web_url.url_scheme(&url)
if ak.string_eq_string_view(&scheme, ak.sv("about")):
resource_loader_handle_about_load_request(this, request, ak.Function3[const u8[], const RequestsRequestTimingInfo*, const HttpHeaderList*, unit](call = ResourceLoaderLoad.about_loaded, context = captures))
return none
if ak.string_eq_string_view(&scheme, ak.sv("resource")):
resource_loader_handle_resource_load_request(this, request, ak.Function1[const ResourceLoaderFileLoadResult*, unit](call = ResourceLoaderLoad.resource_loaded, context = captures),
ak.Function1[ak.ByteString, unit](call = ResourceLoaderLoad.resource_failed, context = captures))
return none
if ak.string_eq_string_view(&scheme, ak.sv("file")):
resource_loader_handle_file_load_request(this, request, ak.Function1[const ResourceLoaderFileLoadResult*, unit](call = ResourceLoaderLoad.file_loaded, context = captures),
ak.Function1[ak.ByteString, unit](call = ResourceLoaderLoad.file_failed, context = captures))
return none
if not ak.string_eq_string_view(&scheme, ak.sv("http")) and not ak.string_eq_string_view(&scheme, ak.sv("https")):
let not_implemented_error = resource_loader_not_implemented_error(&url)
log_failure(request, ak.byte_string_view(¬_implemented_error))
captures.complete(false, RequestsRequestTimingInfo(), ak.byte_string_view(¬_implemented_error))
return none
let maybe_protocol_request = resource_loader_start_network_request(this, request)
if maybe_protocol_request == none:
captures.complete(false, RequestsRequestTimingInfo(), ak.sv("Failed to start network request"))
return none
let protocol_request = maybe_protocol_request else trap("VERIFY_NOT_REACHED")
captures.protocol_request = protocol_request
captures.request_id = requests_request_id(protocol_request)
requests_request_set_unbuffered_request_callbacks(protocol_request, ak.Function3[HttpHeaderList*, u32?, ak.String?, unit](call = ResourceLoaderLoad.protocol_headers_received, context = captures),
ak.Function1[const u8[], unit](call = ResourceLoaderLoad.protocol_data_received, context = captures),
ak.Function3[u64, RequestsRequestTimingInfo, RequestsNetworkError?, unit](call = ResourceLoaderLoad.protocol_complete, context = captures))
return protocol_request
# mark: Network requests ========================================================================
## The lambda of on_certificate_requested: no certificate.
func resource_loader_no_certificate(context: void*?) -> RequestsRequestCertificateAndKey:
return RequestsRequestCertificateAndKey()
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:460 Web::ResourceLoader::start_network_request.
func resource_loader_start_network_request(this: ResourceLoader*, request: const LoadRequest*) -> RequestsRequest*?:
let url = load_request_url(request) else trap("VERIFY: a load request's URL")
let proxy = proxy_mappings_proxy_for_url(proxy_mappings_the(), url)
# FIXME: We could put this request in a queue until the client connection is re-established.
if this.m_request_client == none:
log_failure(request, ak.sv("RequestServer is currently unavailable"))
return none
let request_client = this.m_request_client else trap("VERIFY_NOT_REACHED")
let maybe_protocol_request = requests_request_client_start_request(request_client, load_request_method(request), url, load_request_headers(request),
ak.byte_buffer_bytes_const(load_request_body(request)), load_request_cache_mode(request),
load_request_include_credentials(request), proxy)
if maybe_protocol_request == none:
log_failure(request, ak.sv("Failed to initiate load"))
return none
let protocol_request = maybe_protocol_request else trap("VERIFY_NOT_REACHED")
protocol_request.on_certificate_requested = ak.Function0[RequestsRequestCertificateAndKey](call = resource_loader_no_certificate, context = none)
if let page = load_request_page(request):
var initiator_type_string: ak.String? = none
if let initiator_type = load_request_initiator_type(request):
let initiator = fetch_initiator_type_to_string(initiator_type)
initiator_type_string = ak.fly_string_to_string_const(&initiator)
page_client_page_did_start_network_request(page_client(page), requests_request_id(protocol_request), url, load_request_method(request),
*http_header_list_headers(load_request_headers(request)), ak.byte_buffer_bytes_const(load_request_body(request)), initiator_type_string)
this.m_pending_loads += 1
if ak.function0_is_set(&this.on_load_counter_change):
ak.function0_call(&this.on_load_counter_change)
# m_active_requests.set(*protocol_request): the table lives in the C heap; the root keeps the request.
let root = gc.root_create(protocol_request)
with memory.heap:
_ = ak.hash_map_set(&this.m_active_requests, requests_request_id(protocol_request), root)
return protocol_request
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:495 Web::ResourceLoader::handle_network_response_headers.
func resource_loader_handle_network_response_headers(this: ResourceLoader*, request: const LoadRequest*, response_headers: const HttpHeaderList*):
let page = load_request_page(request) else return
if load_request_include_credentials(request) == HttpIncludeCredentials.yes:
# From https://fetch.spec.whatwg.org/#concept-http-network-fetch:
# 15. If includeCredentials is true, then the user agent should parse and store response
# `Set-Cookie` headers given request and response.
for header in ak.vector_span_const(http_header_list_headers(response_headers)):
let name = ak.byte_string_view(&header.name)
if ak.string_view_equals_ignoring_ascii_case(&name, ak.sv("Set-Cookie")):
store_response_cookies(page, load_request_url(request) else trap("VERIFY: a load request's URL"), ak.byte_string_view(&header.value))
## The captures of finish_network_request's deferred lambda: `[this, protocol_request]`.
struct ResourceLoaderFinishNetworkRequest:
var this: ResourceLoader*
var protocol_request: RequestsRequest*
## The deferred invocation: the request is no longer active.
static func call(context: void*?):
let captures = (ResourceLoaderFinishNetworkRequest*)(context else trap("finish_network_request: no captures"))
let this = captures.this
var removed: gc.Root[RequestsRequest]? = none
with memory.heap:
removed = ak.hash_map_take_k(&this.m_active_requests, requests_request_id(captures.protocol_request))
var root = removed else trap("VERIFY: did_remove")
gc.root_release(&root)
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:512 Web::ResourceLoader::finish_network_request.
func resource_loader_finish_network_request(this: ResourceLoader*, protocol_request: RequestsRequest*):
this.m_pending_loads -= 1
if ak.function0_is_set(&this.on_load_counter_change):
ak.function0_call(&this.on_load_counter_change)
let captures = new ResourceLoaderFinishNetworkRequest(this = this, protocol_request = protocol_request) else trap("out of memory")
core_deferred_invoke(ak.Function0[unit](call = ResourceLoaderFinishNetworkRequest.call, context = captures))