Luce packages
LuceLuce BaseLuciaOS

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)