Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / fetch / infrastructure / http / responses_2.lucb

#==============================================================================================
#
#   responses_2 - Fetch::Infrastructure::FilteredResponse and its four kinds: basic, CORS,
#   opaque and opaque-redirect filtered responses
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp (lines 224-312) with
#       the inline overrides of Responses.h (lines 205-338). A filtered response forwards every
#       virtual accessor to its internal response, except those its kind overrides.
#
#       Copyright (c) 2022-2023, Linus Groh <linusg@serenityos.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: FilteredResponse ========================================================================

## `m_internal_response` of a response that is a FilteredResponse (the `this` of its overrides).
func fetch_filtered_response_internal(base: FetchResponse*) -> FetchResponse*:
    return ((FetchFilteredResponse*)base).m_internal_response

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:212 Web::Fetch::Infrastructure::FilteredResponse::type (override).
pub func fetch_filtered_response_type_impl(base: FetchResponse*) -> FetchResponseType:
    return fetch_response_type(fetch_filtered_response_internal(base))

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:214 Web::Fetch::Infrastructure::FilteredResponse::aborted (override).
pub func fetch_filtered_response_aborted_impl(base: FetchResponse*) -> bool:
    return fetch_response_aborted(fetch_filtered_response_internal(base))

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:215 Web::Fetch::Infrastructure::FilteredResponse::set_aborted (override).
pub func fetch_filtered_response_set_aborted_impl(base: FetchResponse*, aborted: bool):
    fetch_response_set_aborted(fetch_filtered_response_internal(base), aborted)

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:217 Web::Fetch::Infrastructure::FilteredResponse::url_list (override, const).
pub func fetch_filtered_response_url_list_const_impl(base: FetchResponse*) -> const ak.Vector[web_url.Url]*:
    return fetch_response_url_list_const(fetch_filtered_response_internal(base))

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:218 Web::Fetch::Infrastructure::FilteredResponse::url_list (override).
pub func fetch_filtered_response_url_list_impl(base: FetchResponse*) -> ak.Vector[web_url.Url]*:
    return fetch_response_url_list(fetch_filtered_response_internal(base))

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:219 Web::Fetch::Infrastructure::FilteredResponse::set_url_list (override).
pub func fetch_filtered_response_set_url_list_impl(base: FetchResponse*, url_list: ak.Vector[web_url.Url]):
    fetch_response_set_url_list(fetch_filtered_response_internal(base), url_list)

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:221 Web::Fetch::Infrastructure::FilteredResponse::status (override).
pub func fetch_filtered_response_status_impl(base: FetchResponse*) -> u16:
    return fetch_response_status(fetch_filtered_response_internal(base))

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:222 Web::Fetch::Infrastructure::FilteredResponse::set_status (override).
pub func fetch_filtered_response_set_status_impl(base: FetchResponse*, status: u16):
    fetch_response_set_status(fetch_filtered_response_internal(base), status)

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:224 Web::Fetch::Infrastructure::FilteredResponse::status_message (override).
pub func fetch_filtered_response_status_message_impl(base: FetchResponse*) -> ak.ByteString:
    return fetch_response_status_message(fetch_filtered_response_internal(base))

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:225 Web::Fetch::Infrastructure::FilteredResponse::set_status_message (override).
pub func fetch_filtered_response_set_status_message_impl(base: FetchResponse*, status_message: ak.ByteString):
    fetch_response_set_status_message(fetch_filtered_response_internal(base), status_message)

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:227 Web::Fetch::Infrastructure::FilteredResponse::header_list (override).
pub func fetch_filtered_response_header_list_impl(base: FetchResponse*) -> HttpHeaderList*:
    return fetch_response_header_list(fetch_filtered_response_internal(base))

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:228 Web::Fetch::Infrastructure::FilteredResponse::set_header_list (override).
pub func fetch_filtered_response_set_header_list_impl(base: FetchResponse*, header_list: HttpHeaderList*):
    fetch_response_set_header_list(fetch_filtered_response_internal(base), header_list)

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:230 Web::Fetch::Infrastructure::FilteredResponse::body (override).
pub func fetch_filtered_response_body_impl(base: FetchResponse*) -> FetchBody*?:
    return fetch_response_body(fetch_filtered_response_internal(base))

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:231 Web::Fetch::Infrastructure::FilteredResponse::set_body (override).
pub func fetch_filtered_response_set_body_impl(base: FetchResponse*, body: FetchBody*?):
    fetch_response_set_body(fetch_filtered_response_internal(base), body)

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:233 Web::Fetch::Infrastructure::FilteredResponse::cache_state (override).
pub func fetch_filtered_response_cache_state_impl(base: FetchResponse*) -> FetchResponseCacheState?:
    return fetch_response_cache_state(fetch_filtered_response_internal(base))

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:234 Web::Fetch::Infrastructure::FilteredResponse::set_cache_state (override).
pub func fetch_filtered_response_set_cache_state_impl(base: FetchResponse*, cache_state: FetchResponseCacheState?):
    fetch_response_set_cache_state(fetch_filtered_response_internal(base), cache_state)

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:236 Web::Fetch::Infrastructure::FilteredResponse::cors_exposed_header_name_list (override).
pub func fetch_filtered_response_cors_exposed_header_name_list_impl(base: FetchResponse*) -> const ak.Vector[ak.ByteString]*:
    return fetch_response_cors_exposed_header_name_list(fetch_filtered_response_internal(base))

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:237 Web::Fetch::Infrastructure::FilteredResponse::set_cors_exposed_header_name_list (override).
pub func fetch_filtered_response_set_cors_exposed_header_name_list_impl(base: FetchResponse*, cors_exposed_header_name_list: ak.Vector[ak.ByteString]):
    fetch_response_set_cors_exposed_header_name_list(fetch_filtered_response_internal(base), cors_exposed_header_name_list)

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:239 Web::Fetch::Infrastructure::FilteredResponse::range_requested (override).
pub func fetch_filtered_response_range_requested_impl(base: FetchResponse*) -> bool:
    return fetch_response_range_requested(fetch_filtered_response_internal(base))

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:240 Web::Fetch::Infrastructure::FilteredResponse::set_range_requested (override).
pub func fetch_filtered_response_set_range_requested_impl(base: FetchResponse*, range_requested: bool):
    fetch_response_set_range_requested(fetch_filtered_response_internal(base), range_requested)

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:242 Web::Fetch::Infrastructure::FilteredResponse::request_includes_credentials (override).
pub func fetch_filtered_response_request_includes_credentials_impl(base: FetchResponse*) -> bool:
    return fetch_response_request_includes_credentials(fetch_filtered_response_internal(base))

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:243 Web::Fetch::Infrastructure::FilteredResponse::set_request_includes_credentials (override).
pub func fetch_filtered_response_set_request_includes_credentials_impl(base: FetchResponse*, request_includes_credentials: bool):
    fetch_response_set_request_includes_credentials(fetch_filtered_response_internal(base), request_includes_credentials)

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:245 Web::Fetch::Infrastructure::FilteredResponse::timing_allow_passed (override).
pub func fetch_filtered_response_timing_allow_passed_impl(base: FetchResponse*) -> bool:
    return fetch_response_timing_allow_passed(fetch_filtered_response_internal(base))

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:246 Web::Fetch::Infrastructure::FilteredResponse::set_timing_allow_passed (override).
pub func fetch_filtered_response_set_timing_allow_passed_impl(base: FetchResponse*, timing_allow_passed: bool):
    fetch_response_set_timing_allow_passed(fetch_filtered_response_internal(base), timing_allow_passed)

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:248 Web::Fetch::Infrastructure::FilteredResponse::body_info (override).
pub func fetch_filtered_response_body_info_impl(base: FetchResponse*) -> const FetchResponseBodyInfo*:
    return fetch_response_body_info(fetch_filtered_response_internal(base))

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:249 Web::Fetch::Infrastructure::FilteredResponse::set_body_info (override).
pub func fetch_filtered_response_set_body_info_impl(base: FetchResponse*, body_info: FetchResponseBodyInfo):
    fetch_response_set_body_info(fetch_filtered_response_internal(base), body_info)

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:251 Web::Fetch::Infrastructure::FilteredResponse::internal_response
## (`as<FilteredResponse>(*response).internal_response()`).
pub func fetch_filtered_response_internal_response(this: FetchResponse*) -> FetchResponse*:
    return as_fetch_filtered_response(this).m_internal_response

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp:224 Web::Fetch::Infrastructure::FilteredResponse::FilteredResponse.
## (The destructor, Responses.cpp:230, is empty.)
pub func fetch_filtered_response_construct(this: FetchFilteredResponse*, internal_response: FetchResponse*, header_list: HttpHeaderList*):
    fetch_response_construct(this.fetch_response(), header_list)
    this.m_internal_response = internal_response

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp:234 Web::Fetch::Infrastructure::FilteredResponse::visit_edges (override).
pub func fetch_filtered_response_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (FetchFilteredResponse*)base
    fetch_response_visit_edges_impl(base, visitor)
    gc.cell_visitor_visit_t_2(visitor, this.m_internal_response)

## `vm.heap().allocate<T>(internal_response, header_list)` for a filtered response of class `info`: a zeroed cell of
## the VM's heap, garbage collection deferred while the caller runs the constructor and undefers.
func fetch_filtered_response_allocate(vm: Vm*, info: const ak.ClassInfo*) -> gc.Cell*:
    let heap = vm_heap(vm)
    let cell = web_heap_allocate_cell(heap, info)
    gc.heap_defer_gc(heap)
    return cell

# mark: BasicFilteredResponse ===================================================================

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp:240 Web::Fetch::Infrastructure::BasicFilteredResponse::create.
pub func fetch_basic_filtered_response_create(vm: Vm*, internal_response: FetchResponse*) -> FetchBasicFilteredResponse*:
    # A basic filtered response is a filtered response whose type is "basic" and header list excludes
    # any headers in internal response’s header list whose name is a forbidden response-header name.
    let header_list = http_header_list_create()

    for header in &ak.vector_span_const(http_header_list_headers(fetch_response_header_list(internal_response))):
        if not http_is_forbidden_response_header_name(ak.byte_string_view(&header.name)):
            http_header_list_append(header_list, *header)

    let response = (FetchBasicFilteredResponse*)fetch_filtered_response_allocate(vm, &fetch_basic_filtered_response_class)
    fetch_basic_filtered_response_construct(response, internal_response, header_list)
    gc.heap_undefer_gc(vm_heap(vm))
    return response

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp:254 Web::Fetch::Infrastructure::BasicFilteredResponse::BasicFilteredResponse (private).
func fetch_basic_filtered_response_construct(this: FetchBasicFilteredResponse*, internal_response: FetchResponse*, header_list: HttpHeaderList*):
    fetch_filtered_response_construct(this.fetch_filtered_response(), internal_response, header_list)
    this.m_header_list = header_list

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:269 Web::Fetch::Infrastructure::BasicFilteredResponse::type (override).
pub func fetch_basic_filtered_response_type_impl(base: FetchResponse*) -> FetchResponseType:
    return FetchResponseType.basic

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:270 Web::Fetch::Infrastructure::BasicFilteredResponse::header_list (override).
pub func fetch_basic_filtered_response_header_list_impl(base: FetchResponse*) -> HttpHeaderList*:
    return ((FetchBasicFilteredResponse*)base).m_header_list

# mark: CORSFilteredResponse ====================================================================

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp:260 Web::Fetch::Infrastructure::CORSFilteredResponse::create.
pub func fetch_cors_filtered_response_create(vm: Vm*, internal_response: FetchResponse*) -> FetchCorsFilteredResponse*:
    # A CORS filtered response is a filtered response whose type is "cors" and header list excludes
    # any headers in internal response’s header list whose name is not a CORS-safelisted response-header
    # name, given internal response’s CORS-exposed header-name list.
    var cors_exposed_header_name_list = ak.Vector[ak.StringView]()
    let exposed_names = fetch_response_cors_exposed_header_name_list(internal_response)
    ak.vector_ensure_capacity(&cors_exposed_header_name_list, ak.vector_size(exposed_names))

    for header_name in &ak.vector_span_const(exposed_names):
        ak.vector_unchecked_append_u(&cors_exposed_header_name_list, ak.byte_string_view(header_name))

    let header_list = http_header_list_create()
    for header in &ak.vector_span_const(http_header_list_headers(fetch_response_header_list(internal_response))):
        if fetch_is_cors_safelisted_response_header_name(ak.byte_string_view(&header.name), ak.vector_span_const(&cors_exposed_header_name_list)):
            http_header_list_append(header_list, *header)

    let response = (FetchCorsFilteredResponse*)fetch_filtered_response_allocate(vm, &fetch_cors_filtered_response_class)
    fetch_cors_filtered_response_construct(response, internal_response, header_list)
    gc.heap_undefer_gc(vm_heap(vm))
    return response

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp:280 Web::Fetch::Infrastructure::CORSFilteredResponse::CORSFilteredResponse (private).
func fetch_cors_filtered_response_construct(this: FetchCorsFilteredResponse*, internal_response: FetchResponse*, header_list: HttpHeaderList*):
    fetch_filtered_response_construct(this.fetch_filtered_response(), internal_response, header_list)
    this.m_header_list = header_list

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:286 Web::Fetch::Infrastructure::CORSFilteredResponse::type (override).
pub func fetch_cors_filtered_response_type_impl(base: FetchResponse*) -> FetchResponseType:
    return FetchResponseType.cors

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:287 Web::Fetch::Infrastructure::CORSFilteredResponse::header_list (override).
pub func fetch_cors_filtered_response_header_list_impl(base: FetchResponse*) -> HttpHeaderList*:
    return ((FetchCorsFilteredResponse*)base).m_header_list

# mark: OpaqueFilteredResponse ==================================================================

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp:286 Web::Fetch::Infrastructure::OpaqueFilteredResponse::create.
pub func fetch_opaque_filtered_response_create(vm: Vm*, internal_response: FetchResponse*) -> FetchOpaqueFilteredResponse*:
    # An opaque filtered response is a filtered response whose type is "opaque", URL list is the empty list,
    # status is 0, status message is the empty byte sequence, header list is empty, and body is null.
    let response = (FetchOpaqueFilteredResponse*)fetch_filtered_response_allocate(vm, &fetch_opaque_filtered_response_class)
    fetch_opaque_filtered_response_construct(response, internal_response, http_header_list_create())
    gc.heap_undefer_gc(vm_heap(vm))
    return response

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp:293 Web::Fetch::Infrastructure::OpaqueFilteredResponse::OpaqueFilteredResponse (private).
func fetch_opaque_filtered_response_construct(this: FetchOpaqueFilteredResponse*, internal_response: FetchResponse*, header_list: HttpHeaderList*):
    fetch_filtered_response_construct(this.fetch_filtered_response(), internal_response, header_list)
    this.m_header_list = header_list

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:303 Web::Fetch::Infrastructure::OpaqueFilteredResponse::type (override).
pub func fetch_opaque_filtered_response_type_impl(base: FetchResponse*) -> FetchResponseType:
    return FetchResponseType.opaque

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:304 Web::Fetch::Infrastructure::OpaqueFilteredResponse::url_list (override, const).
pub func fetch_opaque_filtered_response_url_list_const_impl(base: FetchResponse*) -> const ak.Vector[web_url.Url]*:
    return &((FetchOpaqueFilteredResponse*)base).m_url_list

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:305 Web::Fetch::Infrastructure::OpaqueFilteredResponse::url_list (override).
pub func fetch_opaque_filtered_response_url_list_impl(base: FetchResponse*) -> ak.Vector[web_url.Url]*:
    return &((FetchOpaqueFilteredResponse*)base).m_url_list

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:306 Web::Fetch::Infrastructure::OpaqueFilteredResponse::status (override).
pub func fetch_opaque_filtered_response_status_impl(base: FetchResponse*) -> u16:
    return 0

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:307 Web::Fetch::Infrastructure::OpaqueFilteredResponse::status_message (override).
pub func fetch_opaque_filtered_response_status_message_impl(base: FetchResponse*) -> ak.ByteString:
    return ((FetchOpaqueFilteredResponse*)base).m_method

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:308 Web::Fetch::Infrastructure::OpaqueFilteredResponse::header_list (override).
pub func fetch_opaque_filtered_response_header_list_impl(base: FetchResponse*) -> HttpHeaderList*:
    return ((FetchOpaqueFilteredResponse*)base).m_header_list

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:309 Web::Fetch::Infrastructure::OpaqueFilteredResponse::body (override).
pub func fetch_opaque_filtered_response_body_impl(base: FetchResponse*) -> FetchBody*?:
    return none

# mark: OpaqueRedirectFilteredResponse ==========================================================

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp:299 Web::Fetch::Infrastructure::OpaqueRedirectFilteredResponse::create.
pub func fetch_opaque_redirect_filtered_response_create(vm: Vm*, internal_response: FetchResponse*) -> FetchOpaqueRedirectFilteredResponse*:
    # An opaque-redirect filtered response is a filtered response whose type is "opaqueredirect",
    # status is 0, status message is the empty byte sequence, header list is empty, and body is null.
    let response = (FetchOpaqueRedirectFilteredResponse*)fetch_filtered_response_allocate(vm, &fetch_opaque_redirect_filtered_response_class)
    fetch_opaque_redirect_filtered_response_construct(response, internal_response, http_header_list_create())
    gc.heap_undefer_gc(vm_heap(vm))
    return response

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp:306 Web::Fetch::Infrastructure::OpaqueRedirectFilteredResponse::OpaqueRedirectFilteredResponse (private).
func fetch_opaque_redirect_filtered_response_construct(this: FetchOpaqueRedirectFilteredResponse*, internal_response: FetchResponse*, header_list: HttpHeaderList*):
    fetch_filtered_response_construct(this.fetch_filtered_response(), internal_response, header_list)
    this.m_header_list = header_list

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:327 Web::Fetch::Infrastructure::OpaqueRedirectFilteredResponse::type (override).
pub func fetch_opaque_redirect_filtered_response_type_impl(base: FetchResponse*) -> FetchResponseType:
    return FetchResponseType.opaque_redirect

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:328 Web::Fetch::Infrastructure::OpaqueRedirectFilteredResponse::status (override).
pub func fetch_opaque_redirect_filtered_response_status_impl(base: FetchResponse*) -> u16:
    return 0

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:329 Web::Fetch::Infrastructure::OpaqueRedirectFilteredResponse::status_message (override).
pub func fetch_opaque_redirect_filtered_response_status_message_impl(base: FetchResponse*) -> ak.ByteString:
    return ((FetchOpaqueRedirectFilteredResponse*)base).m_method

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:330 Web::Fetch::Infrastructure::OpaqueRedirectFilteredResponse::header_list (override).
pub func fetch_opaque_redirect_filtered_response_header_list_impl(base: FetchResponse*) -> HttpHeaderList*:
    return ((FetchOpaqueRedirectFilteredResponse*)base).m_header_list

## Ported from Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h:331 Web::Fetch::Infrastructure::OpaqueRedirectFilteredResponse::body (override).
pub func fetch_opaque_redirect_filtered_response_body_impl(base: FetchResponse*) -> FetchBody*?:
    return none