dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / html / shared_resource_request.lucb
#==============================================================================================
#
# shared_resource_request - HTML::SharedResourceRequest: one image fetch shared by a document
#
# DESCRIPTION:
# Port of LibWeb/HTML/SharedResourceRequest.cpp (lines 1-239) and the inline functions of
# SharedResourceRequest.h: the document's map from URLs to requests, fetching the
# resource and its callbacks, and decoding the fetched bytes into image data (SVG or a
# bitmap through the image codec plugin). Fetching and decoding are phase 2: the fetch,
# the body reader and the decoders are closure stubs.
#
#==============================================================================================
# mark: Creation ================================================================================
## Ported from SharedResourceRequest.cpp:30 Web::HTML::SharedResourceRequest::get_or_create.
pub func html_shared_resource_request_get_or_create(realm: Realm*, page: Page*, url: web_url.Url) -> HtmlSharedResourceRequest*:
let document = html_environment_settings_object_responsible_document(bind_principal_host_defined_environment_settings_object(realm)) else trap("VERIFY: a responsible document")
let shared_resource_requests = dom_document_shared_resource_requests(document)
if let existing = ak.hash_map_get_k(shared_resource_requests, url):
return *existing else trap("a shared resource request")
let request = realm_create_html_shared_resource_request(realm, page, url, document)
_ = ak.hash_map_set(shared_resource_requests, url, request)
return request
## Ported from SharedResourceRequest.cpp:42 Web::HTML::SharedResourceRequest::SharedResourceRequest.
pub func html_shared_resource_request_construct(this: HtmlSharedResourceRequest*, page: Page*, url: web_url.Url, document: DomDocument*):
this.m_page = page
this.m_url = url
this.m_document = document
## Ported from SharedResourceRequest.cpp:51 Web::HTML::SharedResourceRequest::finalize (override).
pub func html_shared_resource_request_finalize_impl(base: gc.Cell*):
let this = (HtmlSharedResourceRequest*)base
gc.cell_finalize_impl(base)
let document = this.m_document else trap("a shared resource request's document")
let shared_resource_requests = dom_document_shared_resource_requests(document)
_ = ak.hash_map_remove_k(shared_resource_requests, this.m_url)
## Ported from SharedResourceRequest.cpp:58 Web::HTML::SharedResourceRequest::visit_edges (override).
pub func html_shared_resource_request_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
let this = (HtmlSharedResourceRequest*)base
gc.cell_visit_edges_impl(base, visitor)
gc.cell_visitor_visit_cell(visitor, (gc.Cell*?)this.m_fetch_controller) # opaque in phase 1
gc.cell_visitor_visit_t(visitor, this.m_document)
gc.cell_visitor_visit_t_2(visitor, this.m_page)
for callback in ak.vector_span(&this.m_callbacks):
gc.cell_visitor_visit_t(visitor, callback.on_finish)
gc.cell_visitor_visit_t(visitor, callback.on_fail)
gc.cell_visitor_visit_t(visitor, this.m_image_data)
# mark: Accessors ===============================================================================
## Ported from SharedResourceRequest.cpp:71 Web::HTML::SharedResourceRequest::image_data.
pub func html_shared_resource_request_image_data(this: HtmlSharedResourceRequest*) -> HtmlDecodedImageData*?:
return this.m_image_data
## Ported from SharedResourceRequest.cpp:76 Web::HTML::SharedResourceRequest::fetch_controller.
pub func html_shared_resource_request_fetch_controller(this: HtmlSharedResourceRequest*) -> FetchController*?:
return this.m_fetch_controller
## Ported from SharedResourceRequest.cpp:81 Web::HTML::SharedResourceRequest::set_fetch_controller.
pub func html_shared_resource_request_set_fetch_controller(this: HtmlSharedResourceRequest*, fetch_controller: FetchController*?):
this.m_fetch_controller = fetch_controller
## Ported from SharedResourceRequest.h:29 Web::HTML::SharedResourceRequest::url.
pub func html_shared_resource_request_url(this: HtmlSharedResourceRequest*) -> web_url.Url:
return this.m_url
# mark: Fetching ================================================================================
## The captures of fetch_resource's process_response: `[this, &realm, request]`.
struct HtmlSharedResourceRequestFetch:
var this: HtmlSharedResourceRequest*
var realm: Realm*
var request: FetchRequest*
var response: FetchResponse*?
## process_response.
static func process_response(context: void*?, response_: FetchResponse*):
let captures = (HtmlSharedResourceRequestFetch*)(context else trap("processResponse: no captures"))
let this = captures.this
# FIXME: If the response is CORS cross-origin, we must use its internal response to query any of its data. See:
# https://github.com/whatwg/html/issues/9355
let response = fetch_response_unsafe_response(response_)
# process_body and process_body_error capture [this, request, response] and [this].
let body_captures = new HtmlSharedResourceRequestFetch(this = this, realm = captures.realm, request = captures.request, response = response) else trap("out of memory")
let heap = gc.cell_heap(this.cell())
let process_body = gc.create_function1(heap, ak.Function1[ak.ByteBuffer, unit](call = HtmlSharedResourceRequestFetch.process_body, context = body_captures))
let process_body_error = gc.create_function1(heap, ak.Function1[JsValue, unit](call = HtmlSharedResourceRequestFetch.process_body_error, context = body_captures))
# Check for failed fetch response
let body = fetch_response_body(response)
if not fetch_is_ok_status(fetch_response_status(response)) or body == none:
html_shared_resource_request_handle_failed_fetch(this)
return
fetch_body_fully_read(body else trap("VERIFY_NOT_REACHED"), captures.realm, process_body, process_body_error, .js_object(realm_global_object(captures.realm)))
## process_body.
static func process_body(context: void*?, data: ak.ByteBuffer):
let captures = (HtmlSharedResourceRequestFetch*)(context else trap("processBody: no captures"))
let response = captures.response else trap("processBody: no response")
let extracted_mime_type = fetch_extract_mime_type(fetch_response_header_list(response))
var mime_type = ak.StringView()
var essence = ak.string_new()
if let mime = extracted_mime_type:
essence = mime_type_essence(&mime)
mime_type = ak.string_bytes_as_string_view(&essence)
html_shared_resource_request_handle_successful_fetch(captures.this, fetch_request_url(captures.request), mime_type, data)
## process_body_error.
static func process_body_error(context: void*?, error_: JsValue):
let captures = (HtmlSharedResourceRequestFetch*)(context else trap("processBodyError: no captures"))
html_shared_resource_request_handle_failed_fetch(captures.this)
## Ported from SharedResourceRequest.cpp:86 Web::HTML::SharedResourceRequest::fetch_resource.
pub func html_shared_resource_request_fetch_resource(this: HtmlSharedResourceRequest*, realm: Realm*, request: FetchRequest*):
let captures = new HtmlSharedResourceRequestFetch(this = this, realm = realm, request = request, response = none) else trap("out of memory")
this.m_state = HtmlSharedResourceRequestState.fetching
# m_load_event_delayer.emplace(*m_document): a previous delayer, if any, is destroyed first.
if let delayer = this.m_load_event_delayer:
var released = delayer
dom_document_load_event_delayer_destruct(&released)
var delayer: DomDocumentLoadEventDelayer = ---
dom_document_load_event_delayer_construct(&delayer, this.m_document else trap("a shared resource request's document"))
this.m_load_event_delayer = delayer
let fetch_controller = fetch_fetching_fetch(realm, request, fetch_algorithms_create_with_process_response(realm_vm(realm), ak.Function1[FetchResponse*, unit](call = HtmlSharedResourceRequestFetch.process_response, context = captures)))
html_shared_resource_request_set_fetch_controller(this, fetch_controller)
## Ported from SharedResourceRequest.cpp:123 Web::HTML::SharedResourceRequest::add_callbacks.
pub func html_shared_resource_request_add_callbacks(this: HtmlSharedResourceRequest*, on_finish: ak.Function0[unit], on_fail: ak.Function0[unit]):
if this.m_state == HtmlSharedResourceRequestState.finished:
if ak.function0_is_set(&on_finish):
ak.function0_call(&on_finish)
return
if this.m_state == HtmlSharedResourceRequestState.failed:
if ak.function0_is_set(&on_fail):
ak.function0_call(&on_fail)
return
var callbacks = HtmlSharedResourceRequestCallbacks()
let heap = gc.cell_heap(this.cell())
if ak.function0_is_set(&on_finish):
callbacks.on_finish = gc.create_function0(heap, on_finish)
if ak.function0_is_set(&on_fail):
callbacks.on_fail = gc.create_function0(heap, on_fail)
ak.vector_append_t(&this.m_callbacks, callbacks)
# mark: Handling the fetched resource ===========================================================
## handle_successful_fetch's handle_successful_bitmap_decode and handle_failed_decode
## (`[strong_this = GC::Root(*this)]`: the captures are managed memory, which keeps the request).
struct HtmlSharedResourceRequestDecode:
var strong_this: HtmlSharedResourceRequest*
## handle_successful_bitmap_decode.
static func decoded(context: void*?, result: PlatformDecodedImage*):
let captures = (HtmlSharedResourceRequestDecode*)(context else trap("decode: no captures"))
let strong_this = captures.strong_this
let realm = dom_document_realm(strong_this.m_document else trap("a shared resource request's document"))
if result.session_id != 0:
# Streaming animated decode: create AnimatedDecodedImageData.
var initial_bitmaps: ak.Vector[gfx.Bitmap*]
ak.vector_ensure_capacity(&initial_bitmaps, ak.vector_size(&result.frames))
for frame in ak.vector_span(&result.frames):
ak.vector_append_t(&initial_bitmaps, frame.bitmap else trap("a decoded frame has a bitmap"))
let first_bitmap = ak.vector_first(&result.frames).bitmap else trap("a decoded frame has a bitmap")
let size = gfx.bitmap_size(first_bitmap)
strong_this.m_image_data = html_animated_decoded_image_data_create(realm, result.session_id, result.frame_count, result.loop_count, size, result.color_space, result.all_durations, initial_bitmaps).html_decoded_image_data()
else:
# Single-shot decode: create BitmapDecodedImageData as before.
var frames: ak.Vector[HtmlBitmapDecodedImageDataFrame]
for frame in ak.vector_span(&result.frames):
let bitmap = frame.bitmap else trap("a decoded frame has a bitmap")
ak.vector_append_t(&frames, HtmlBitmapDecodedImageDataFrame(bitmap = gfx.immutable_bitmap_create_color_space(bitmap, result.color_space), duration = (i32)frame.duration))
strong_this.m_image_data = html_bitmap_decoded_image_data_create(realm, frames, (usize)result.loop_count, result.is_animated) else trap("FIXME: should propagate errors")
html_shared_resource_request_handle_successful_resource_load(strong_this)
## handle_failed_decode.
static func failed(context: void*?, error_: ak.AkError*):
let captures = (HtmlSharedResourceRequestDecode*)(context else trap("decode failed: no captures"))
html_shared_resource_request_handle_failed_fetch(captures.strong_this)
## Ported from SharedResourceRequest.cpp:146 Web::HTML::SharedResourceRequest::handle_successful_fetch.
pub func html_shared_resource_request_handle_successful_fetch(this: HtmlSharedResourceRequest*, url_string: web_url.Url, mime_type: ak.StringView, data: ak.ByteBuffer):
# AD-HOC: At this point, things gets very ad-hoc.
# FIXME: Bring this closer to spec.
var is_svg_image = ak.string_view_eq_string_view(&mime_type, ak.sv("image/svg+xml"))
if not is_svg_image and ak.string_view_is_empty(&mime_type):
let basename = web_url.url_basename(&url_string)
let basename_view = ak.byte_string_view(&basename)
is_svg_image = ak.string_view_ends_with_string_view(&basename_view, ak.sv(".svg"))
if is_svg_image:
let document = this.m_document else trap("a shared resource request's document")
let result = svg_decoded_image_data_create(dom_document_realm(document), this.m_page, url_string, ak.byte_buffer_bytes_const(&data)) catch:
html_shared_resource_request_handle_failed_fetch(this)
return
this.m_image_data = result.html_decoded_image_data()
html_shared_resource_request_handle_successful_resource_load(this)
return
let captures = new HtmlSharedResourceRequestDecode(strong_this = this) else trap("out of memory")
_ = platform_image_codec_plugin_decode_image(platform_image_codec_plugin_the(), ak.byte_buffer_bytes_const(&data), ak.Function1[PlatformDecodedImage*, unit](call = HtmlSharedResourceRequestDecode.decoded, context = captures), ak.Function1[ak.AkError*, unit](call = HtmlSharedResourceRequestDecode.failed, context = captures))
## `m_load_event_delayer.clear()`: destroys a held delayer.
func html_shared_resource_request_clear_load_event_delayer(this: HtmlSharedResourceRequest*):
if let delayer = this.m_load_event_delayer:
var released = delayer
dom_document_load_event_delayer_destruct(&released)
this.m_load_event_delayer = none
## Ported from SharedResourceRequest.cpp:207 Web::HTML::SharedResourceRequest::handle_failed_fetch.
pub func html_shared_resource_request_handle_failed_fetch(this: HtmlSharedResourceRequest*):
this.m_state = HtmlSharedResourceRequestState.failed
html_shared_resource_request_clear_load_event_delayer(this)
for callback in ak.vector_span(&this.m_callbacks):
if let on_fail = callback.on_fail:
ak.function0_call(&on_fail.function)
ak.vector_clear(&this.m_callbacks)
## Ported from SharedResourceRequest.cpp:218 Web::HTML::SharedResourceRequest::handle_successful_resource_load.
pub func html_shared_resource_request_handle_successful_resource_load(this: HtmlSharedResourceRequest*):
this.m_state = HtmlSharedResourceRequestState.finished
html_shared_resource_request_clear_load_event_delayer(this)
for callback in ak.vector_span(&this.m_callbacks):
if let on_finish = callback.on_finish:
ak.function0_call(&on_finish.function)
ak.vector_clear(&this.m_callbacks)
## Ported from SharedResourceRequest.cpp:229 Web::HTML::SharedResourceRequest::needs_fetching.
pub func html_shared_resource_request_needs_fetching(this: HtmlSharedResourceRequest*) -> bool:
return this.m_state == HtmlSharedResourceRequestState.new_
## Ported from SharedResourceRequest.cpp:234 Web::HTML::SharedResourceRequest::is_fetching.
pub func html_shared_resource_request_is_fetching(this: HtmlSharedResourceRequest*) -> bool:
return this.m_state == HtmlSharedResourceRequestState.fetching