dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / loader / resource_loader_2.lucb
#==============================================================================================
#
# resource_loader_2 - ResourceLoader::load: about:, resource: and file: loads in process,
# http(s): loads through the RequestClient seam
#
# DESCRIPTION:
# Port of Libraries/LibWeb/Loader/ResourceLoader.cpp (lines 198-522). The C++ templates
# over handler lambdas take AK Functions here; each lambda's captures are a struct in
# managed memory named after its function, beside the function that makes it (DESIGN.md
# §2.7). A file: load asks the page's client to open the file (PageClient::request_file,
# which the embedder implements; in_process_request_client.lucb has an implementation)
# and reads the descriptor it gets back. An active network request is rooted in
# m_active_requests until its completion has been handled.
#
# Copyright (c) 2018-2024, Andreas Kling <andreas@ladybird.org>
# Copyright (c) 2022, Dex♪ <dexes.ttp@gmail.com>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: file: ===================================================================================
## The captures of handle_file_load_request's FileRequest callback: `[this, request, on_file, on_error, url]`.
struct ResourceLoaderHandleFileLoadRequest:
var this: ResourceLoader*
var request: LoadRequest
var on_file: ak.Function1[const ResourceLoaderFileLoadResult*, unit]
var on_error: ak.Function1[ak.ByteString, unit]
var url: web_url.Url
## The FileRequest's on_file_request_finish: the file at the request's path, opened (or not) by the page's client.
static func file_request_finished(context: void*?, file_or_error: ErrorOrI32):
let captures = (ResourceLoaderHandleFileLoadRequest*)(context else trap("file request: no captures"))
let this = captures.this
this.m_pending_loads -= 1
if ak.function0_is_set(&this.on_load_counter_change):
ak.function0_call(&this.on_load_counter_change)
var fd: i32 = -1
match file_or_error:
.ak_error(failure):
let message = resource_loader_format_error(failure)
ak.function1_call(&captures.on_error, message)
return
.value(descriptor):
fd = descriptor
# Core::Directory::is_valid_directory(fd)
let maybe_directory: std_files.Metadata? = core_system_fstat(fd) catch:
recover none
if let directory = maybe_directory:
if core_system_is_directory(&directory):
# (The C++ leaves the directory's descriptor open; the port closes it.)
core_system_close(fd)
let maybe_response = load_file_directory_page(captures.url) catch failure:
let message = resource_loader_format_failure(failure)
ak.function1_call(&captures.on_error, message)
return
var headers: ak.Vector[HttpHeader]
ak.vector_append_t(&headers, http_header_create(ak.sv("Content-Type"), ak.sv("text/html")))
let response_view = ak.string_bytes_as_string_view(&maybe_response)
let load_result = ResourceLoaderFileLoadResult(data = ak.string_view_bytes(&response_view), response_headers = http_header_list_create(headers))
ak.function1_call(&captures.on_file, &load_result)
return
let st = core_system_fstat(fd) catch failure:
let message = resource_loader_format_failure(failure)
ak.function1_call(&captures.on_error, message)
return
let data = core_file_read_until_eof(fd) catch failure:
let message = resource_loader_format_failure(failure)
ak.function1_call(&captures.on_error, message)
return
let request_url = load_request_url(&captures.request) else trap("VERIFY: a load request's URL")
let file_path = web_url.url_file_path(&request_url)
let load_result = ResourceLoaderFileLoadResult(data = ak.byte_buffer_bytes_const(&data), response_headers = response_headers_for_file(ak.byte_string_view(&file_path), st.modified.seconds))
ak.function1_call(&captures.on_file, &load_result)
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:201 Web::ResourceLoader::handle_file_load_request.
func resource_loader_handle_file_load_request(this: ResourceLoader*, request: LoadRequest*, on_file: ak.Function1[const ResourceLoaderFileLoadResult*, unit], on_error: ak.Function1[ak.ByteString, unit]):
let maybe_page = load_request_page(request)
if maybe_page == none:
let error_message = ak.byte_string_from_str("INTERNAL ERROR: No Page for file scheme request")
ak.function1_call(&on_error, error_message)
return
let page = maybe_page else trap("VERIFY_NOT_REACHED")
let url = load_request_url(request) else trap("VERIFY: a load request's URL")
let captures = new ResourceLoaderHandleFileLoadRequest(this = this, request = *request, on_file = on_file, on_error = on_error, url = url) else trap("out of memory")
var file_request = FileRequest()
file_request_construct(&file_request, web_url.url_file_path(&url), ak.Function1[ErrorOrI32, unit](call = ResourceLoaderHandleFileLoadRequest.file_request_finished, context = captures))
page_client_request_file(page_client(page), file_request)
this.m_pending_loads += 1
if ak.function0_is_set(&this.on_load_counter_change):
ak.function0_call(&this.on_load_counter_change)
# mark: about: ==================================================================================
## The captures of handle_about_load_request's deferred lambda: `[callback, timing_info, response_headers]`.
struct ResourceLoaderHandleAboutLoadRequest:
var callback: ak.Function3[const u8[], const RequestsRequestTimingInfo*, const HttpHeaderList*, unit]
var timing_info: RequestsRequestTimingInfo
var response_headers: HttpHeaderList*
## The deferred invocation: an empty page.
static func call(context: void*?):
let captures = (ResourceLoaderHandleAboutLoadRequest*)(context else trap("about: load: no captures"))
let buffer = ak.ByteBuffer()
ak.function3_call(&captures.callback, ak.byte_buffer_bytes_const(&buffer), &captures.timing_info, captures.response_headers)
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:276 Web::ResourceLoader::handle_about_load_request.
func resource_loader_handle_about_load_request(this: ResourceLoader*, request: const LoadRequest*, callback: ak.Function3[const u8[], const RequestsRequestTimingInfo*, const HttpHeaderList*, unit]):
let url = load_request_url(request) else trap("VERIFY: a load request's URL")
if resource_loader_spam_debug:
let text = web_url.url_to_byte_string(&url)
ak.dbgln(f"Loading about: URL {ak.string_view_text(ak.byte_string_view(&text))}")
var headers: ak.Vector[HttpHeader]
ak.vector_append_t(&headers, http_header_create(ak.sv("Content-Type"), ak.sv("text/html; charset=UTF-8")))
let response_headers = http_header_list_create(headers)
# FIXME: Implement timing info for about requests.
let timing_info = RequestsRequestTimingInfo()
let serialized = web_url.url_serialize_path(&url)
let serialized_path = web_url.percent_decode(ak.string_bytes_as_string_view(&serialized))
var target = ak.string_builder_new()
ak.string_builder_append_string_view(&target, ak.byte_string_view(&serialized_path))
ak.string_builder_append(&target, ".html")
let target_file = ak.string_builder_to_byte_string(&target)
let about_directory = core_resource_load_from_uri(ak.sv("resource://ladybird/about-pages")) else trap("MUST: Core::Resource::load_from_uri")
let children = core_resource_children(about_directory)
var contains = false
for child in ak.vector_span_const(&children):
if ak.string_eq_string_view(&child, ak.byte_string_view(&target_file)):
contains = true
if contains:
var uri = ak.string_builder_new()
ak.string_builder_append(&uri, "resource://ladybird/about-pages/")
ak.string_builder_append_string_view(&uri, ak.byte_string_view(&target_file))
let resource: CoreResource*? = core_resource_load_from_uri(ak.string_builder_string_view(&uri)) catch:
recover none
if let loaded = resource:
ak.function3_call(&callback, core_resource_data(loaded), &timing_info, response_headers)
return
let captures = new ResourceLoaderHandleAboutLoadRequest(callback = callback, timing_info = timing_info, response_headers = response_headers) else trap("out of memory")
platform_event_loop_plugin_deferred_invoke(platform_event_loop_plugin_the(),
gc.create_function0(this.m_heap, ak.Function0[unit](call = ResourceLoaderHandleAboutLoadRequest.call, context = captures)))
# mark: resource: ===============================================================================
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:312 Web::ResourceLoader::handle_resource_load_request.
func resource_loader_handle_resource_load_request(this: ResourceLoader*, request: const LoadRequest*, on_resource: ak.Function1[const ResourceLoaderFileLoadResult*, unit], on_error: ak.Function1[ak.ByteString, unit]):
let url = load_request_url(request) else trap("VERIFY: a load request's URL")
let serialized = web_url.url_serialize(&url)
let resource_value = core_resource_load_from_uri(ak.string_bytes_as_string_view(&serialized)) catch failure:
let message = resource_loader_format_failure(failure)
ak.function1_call(&on_error, message)
return
# When resource URI is a directory use file directory loader to generate response
if core_resource_is_directory(resource_value):
let file_url = core_resource_file_url(resource_value)
let directory_url = web_url.parser_basic_parse(ak.string_bytes_as_string_view(&file_url)) else trap("VERIFY: a directory resource's file URL")
let maybe_response = load_file_directory_page(directory_url) catch failure:
let message = resource_loader_format_failure(failure)
ak.function1_call(&on_error, message)
return
var headers: ak.Vector[HttpHeader]
ak.vector_append_t(&headers, http_header_create(ak.sv("Content-Type"), ak.sv("text/html")))
let response_view = ak.string_bytes_as_string_view(&maybe_response)
let load_result = ResourceLoaderFileLoadResult(data = ak.string_view_bytes(&response_view), response_headers = http_header_list_create(headers))
ak.function1_call(&on_resource, &load_result)
return
# FIXME: Implement timing info for resource requests.
let timing_info = RequestsRequestTimingInfo()
let file_path = web_url.url_file_path(&url)
let load_result = ResourceLoaderFileLoadResult(data = core_resource_data(resource_value),
response_headers = response_headers_for_file(ak.byte_string_view(&file_path), core_resource_modified_time(resource_value)),
timing_info = timing_info)
ak.function1_call(&on_resource, &load_result)