dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / html / html_track_element.lucb
#==============================================================================================
#
# html_track_element - HTML::HTMLTrackElement: <track> and its text track
#
# DESCRIPTION:
# Port of LibWeb/HTML/HTMLTrackElement.cpp (lines 1-285) and the inline members of
# HTMLTrackElement.h: construction (which moves the mixin tables to HTMLTrackElement's,
# as C++'s vptrs move), initialize (the TextTrack and its observer), visit_edges, the
# kind / label / srclang / src / id attributes, the insertion steps, readyState, the
# track URL and the track processing model (fetching is phase 2; TextTrack, its observer
# and Fetch go to closure stubs).
#
#==============================================================================================
# mark: Construction ============================================================================
## Ported from HTMLTrackElement.cpp:27 Web::HTML::HTMLTrackElement::HTMLTrackElement.
pub func html_track_element_construct(this: HtmlTrackElement*, document: DomDocument*, qualified_name: DomQualifiedName):
html_element_construct(this.html_element(), document, qualified_name)
# The vptrs of the mixin bases move to HTMLTrackElement's tables.
let element = this.html_element()
element.element.slottable_mixin.vtable = &html_track_element_slottable_mixin_vtable
element.element.aria_mixin.vtable = &html_track_element_aria_mixin_vtable
element.element.animatable.vtable = &html_track_element_animatable_vtable
element.global_event_handlers.vtable = &html_track_element_global_event_handlers_vtable
element.form_associated_element.vtable = &html_track_element_form_associated_element_vtable
## Ported from HTMLTrackElement.cpp:34 Web::HTML::HTMLTrackElement::initialize (override).
pub func html_track_element_initialize_impl(base: JsCell*, realm: Realm*):
let this = (HtmlTrackElement*)base
web_set_prototype_for_interface(base, realm, BindInterfaceName.html_track_element)
html_element_initialize_impl(base, realm)
let track = html_text_track_create(realm)
this.m_track = track
this.m_track_observer = realm_create_html_text_track_observer(realm, realm, track)
## Ported from HTMLTrackElement.cpp:43 Web::HTML::HTMLTrackElement::visit_edges (override).
pub func html_track_element_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
let this = (HtmlTrackElement*)base
html_element_visit_edges_impl(base, visitor)
gc.cell_visitor_visit_cell(visitor, (gc.Cell*?)this.m_track) # opaque in phase 1
gc.cell_visitor_visit_cell(visitor, (gc.Cell*?)this.m_track_observer) # opaque in phase 1
gc.cell_visitor_visit_cell(visitor, (gc.Cell*?)this.m_fetch_algorithms) # opaque in phase 1
gc.cell_visitor_visit_cell(visitor, (gc.Cell*?)this.m_fetch_controller) # opaque in phase 1
## The element's text track (`*m_track`, set by initialize).
func html_track_element_text_track(this: HtmlTrackElement*) -> HtmlTextTrack*:
return this.m_track else trap("HTMLTrackElement: no text track before initialize")
## `value.value_or({})` of an attribute value.
func html_track_element_value_or_empty(value: ak.String?) -> ak.String:
if let present = value:
return present
return ak.string_new()
## Ported from HTMLTrackElement.cpp:52 Web::HTML::HTMLTrackElement::attribute_changed (override).
pub func html_track_element_attribute_changed_impl(base: DomElement*, name: ak.FlyString, old_value: ak.String?, value: ak.String?, namespace_: ak.FlyString?):
let this = (HtmlTrackElement*)base
html_element_attribute_changed_impl(base, name, old_value, value, namespace_)
# https://html.spec.whatwg.org/multipage/media.html#sourcing-out-of-band-text-tracks
# As the kind, label, and srclang attributes are set, changed, or removed, the text track must update accordingly, as per the definitions above.
if ak.fly_string_equals_ignoring_ascii_case_fly_string(&name, &html_attribute_names_kind):
html_text_track_set_kind(html_track_element_text_track(this), html_text_track_kind_from_string(html_track_element_value_or_empty(value)))
elif ak.fly_string_equals_ignoring_ascii_case_fly_string(&name, &html_attribute_names_label):
html_text_track_set_label(html_track_element_text_track(this), html_track_element_value_or_empty(value))
elif ak.fly_string_equals_ignoring_ascii_case_fly_string(&name, &html_attribute_names_srclang):
html_text_track_set_language(html_track_element_text_track(this), html_track_element_value_or_empty(value))
elif ak.fly_string_equals_ignoring_ascii_case_fly_string(&name, &html_attribute_names_src):
# https://html.spec.whatwg.org/multipage/media.html#sourcing-out-of-band-text-tracks:attr-track-src
# FIXME: Whenever a track element has its src attribute set, changed, or removed, the user agent must immediately empty the element's text track's text track list of cues.
# (This also causes the algorithm above to stop adding cues from the resource being obtained using the previously given URL, if any.)
let src = value else return
# https://html.spec.whatwg.org/multipage/media.html#attr-track-src
# When the element's src attribute is set, run these steps:
# 1. Let trackURL be failure.
var track_url: ak.String? = none
# 2. Let value be the element's src attribute value.
# 3. If value is not the empty string, then set trackURL to the result of encoding-parsing-and-serializing a URL given value, relative to the element's node document.
if not ak.string_is_empty(&src):
track_url = dom_document_encoding_parse_and_serialize_url(dom_node_document(this.dom_node()), ak.string_bytes_as_string_view(&src))
# 4. Set the element's track URL to trackURL if it is not failure; otherwise to the empty string.
html_track_element_set_track_url(this, html_track_element_value_or_empty(track_url))
# https://html.spec.whatwg.org/multipage/media.html#dom-texttrack-id
# For tracks that correspond to track elements, the track's identifier is the value of the element's id attribute, if any.
if ak.fly_string_equals_ignoring_ascii_case_fly_string(&name, &html_attribute_names_id):
html_text_track_set_id(html_track_element_text_track(this), html_track_element_value_or_empty(value))
## Ported from HTMLTrackElement.cpp:94 Web::HTML::HTMLTrackElement::inserted (override).
pub func html_track_element_inserted_impl(base: DomNode*):
let this = (HtmlTrackElement*)base
html_element_inserted_impl(base)
# AD-HOC: This is a hack to allow tracks to start loading, without needing to implement the entire
# "honor user preferences for automatic text track selection" AO detailed here:
# https://html.spec.whatwg.org/multipage/media.html#honor-user-preferences-for-automatic-text-track-selection
html_text_track_set_mode(html_track_element_text_track(this), BindTextTrackMode.hidden)
html_track_element_start_the_track_processing_model(this)
## Ported from HTMLTrackElement.cpp:108 Web::HTML::HTMLTrackElement::ready_state.
# https://html.spec.whatwg.org/multipage/media.html#dom-track-readystate
pub func html_track_element_ready_state(this: HtmlTrackElement*) -> u16:
# The readyState attribute must return the numeric value corresponding to the text track readiness state of the track element's text track, as defined by the following list:
match html_text_track_readiness_state(html_track_element_text_track(this)):
.not_loaded:
# NONE (numeric value 0)
# The text track not loaded state.
return 0
.loading:
# LOADING (numeric value 1)
# The text track loading state.
return 1
.loaded:
# LOADED (numeric value 2)
# The text track loaded state.
return 2
.failed_to_load:
# ERROR (numeric value 3)
# The text track failed to load state.
return 3
_:
trap("VERIFY_NOT_REACHED: TextTrack::ReadinessState")
## Ported from HTMLTrackElement.h:24 Web::HTML::HTMLTrackElement::track.
pub func html_track_element_track(this: HtmlTrackElement*) -> HtmlTextTrack*:
return html_track_element_text_track(this)
## Ported from HTMLTrackElement.h:32 Web::HTML::HTMLTrackElement::track_url.
pub func html_track_element_track_url(this: HtmlTrackElement*) -> ak.String:
return this.m_track_url
## Whether a track's mode is one of hidden or showing (`first_is_one_of(mode, Hidden, Showing)`).
func html_track_element_mode_is_hidden_or_showing(mode: BindTextTrackMode) -> bool:
return mode == BindTextTrackMode.hidden or mode == BindTextTrackMode.showing
## Ported from HTMLTrackElement.cpp:135 Web::HTML::HTMLTrackElement::set_track_url.
pub func html_track_element_set_track_url(this: HtmlTrackElement*, track_url: ak.String):
if ak.string_equals(&this.m_track_url, &track_url):
return
this.m_track_url = track_url
let track_is_hidden_or_showing = html_track_element_mode_is_hidden_or_showing(html_text_track_mode(html_track_element_text_track(this)))
# https://html.spec.whatwg.org/multipage/media.html#start-the-track-processing-model
if this.m_loading and this.m_fetch_controller != none and track_is_hidden_or_showing:
this.m_loading = false
fetch_controller_abort(this.m_fetch_controller else trap("unreachable"), html_element_realm(this.html_element()), none)
# https://html.spec.whatwg.org/multipage/media.html#start-the-track-processing-model
if this.m_awaiting_track_url_change and track_is_hidden_or_showing:
this.m_awaiting_track_url_change = false
# 13. Jump to the step labeled top.
html_track_element_start_the_track_processing_model_parallel_steps(this)
# mark: The track processing model ==============================================================
## start_the_track_processing_model's deferred steps: `[this]() { start_the_track_processing_model_parallel_steps(); }`.
func html_track_element_parallel_steps_task(context: void*?):
html_track_element_start_the_track_processing_model_parallel_steps((HtmlTrackElement*)(context else trap("track processing: no element")))
## Ported from HTMLTrackElement.cpp:159 Web::HTML::HTMLTrackElement::start_the_track_processing_model.
# https://html.spec.whatwg.org/multipage/media.html#start-the-track-processing-model
pub func html_track_element_start_the_track_processing_model(this: HtmlTrackElement*):
let realm = html_element_realm(this.html_element())
# 1. If another occurrence of this algorithm is already running for this text track and its track element, return,
# letting that other algorithm take care of this element.
if this.m_loading:
return
# 2. If the text track's text track mode is not set to one of hidden or showing, then return.
if not html_track_element_mode_is_hidden_or_showing(html_text_track_mode(html_track_element_text_track(this))):
return
# 3. If the text track's track element does not have a media element as a parent, return.
let parent = dom_node_parent_element(this.dom_node())
if parent == none or not is_html_media_element(parent else trap("unreachable")):
return
this.m_loading = true
# 4. Run the remainder of these steps in parallel, allowing whatever caused these steps to run to continue.
platform_event_loop_plugin_deferred_invoke(platform_event_loop_plugin_the(), gc.create_function0(realm_heap(realm), ak.Function0[unit](call = html_track_element_parallel_steps_task, context = this)))
## The captures of the track fetch's process_response_consume_body: `[this, &realm]`.
func html_track_element_process_response_consume_body(context: void*?, response: FetchResponse*, body_bytes: FetchAlgorithmsBodyBytes):
let this = (HtmlTrackElement*)(context else trap("track fetch: no element"))
this.m_loading = false
# If fetching fails for any reason (network error, the server returns an error code, CORS fails, etc.),
# or if URL is the empty string, then queue an element task on the DOM manipulation task source given the media element
# to first change the text track readiness state to failed to load and then fire an event named error at the track element.
var body_failed = false
match body_bytes:
.empty:
body_failed = true
.fetch_algorithms_consume_body_failure_tag(_):
body_failed = true
.byte_buffer(_):
body_failed = false
if fetch_response_url(response) == none or body_failed or not fetch_is_ok_status(fetch_response_status(response)) or fetch_response_is_network_error(response):
html_track_element_track_failed_to_load(this)
return
# If fetching does not fail, but the type of the resource is not a supported text track format, or the file was not successfully processed
# (e.g., the format in question is an XML format and the file contained a well-formedness error that XML requires be detected and reported to the application),
# then the task that is queued on the networking task source in which the aforementioned problem is found must change the text track readiness state to failed to
# load and fire an event named error at the track element.
# FIXME: Currently we always fail here, since we don't support loading any track formats.
html_track_element_track_failed_to_load(this)
# If fetching does not fail, and the file was successfully processed, then the final task that is queued by the networking task source,
# after it has finished parsing the data, must change the text track readiness state to loaded, and fire an event named load at the track element.
# FIXME: Enable this once we support processing track files
# (C++: `if (false) { queue_an_element_task(Task::Source::Networking, [this, &realm]() { m_track->set_readiness_state(Loaded); dispatch_event(load); }); }`)
## The track readiness observer: `[this, url = move(url)](TextTrack::ReadinessState) mutable { ... }`.
func html_track_element_track_readiness_changed(context: void*?, readiness_state: HtmlTextTrackReadinessState):
let this = (HtmlTrackElement*)(context else trap("track readiness observer: no element"))
if html_text_track_readiness_state(html_track_element_text_track(this)) != HtmlTextTrackReadinessState.loading:
html_track_element_track_became_ready(this)
## Ported from HTMLTrackElement.cpp:183 Web::HTML::HTMLTrackElement::start_the_track_processing_model_parallel_steps.
pub func html_track_element_start_the_track_processing_model_parallel_steps(this: HtmlTrackElement*):
let realm = html_element_realm(this.html_element())
let track = html_track_element_text_track(this)
# 5. Top: Await a stable state. The synchronous section consists of the following steps.
# 6. ⌛ Set the text track readiness state to loading.
html_text_track_set_readiness_state(track, HtmlTextTrackReadinessState.loading)
# 7. ⌛ Let URL be the track URL of the track element.
let url = html_track_element_track_url(this)
# 8. ⌛ If the track element's parent is a media element, then let corsAttributeState be the state of the
# parent media element's crossorigin content attribute. Otherwise, let corsAttributeState be No CORS.
var cors_attribute_state = HtmlCorsSettingAttribute.no_cors
if let parent = tree_node_parent(this.dom_node()):
if let media_element = as_if_html_media_element(parent):
cors_attribute_state = html_media_element_crossorigin(media_element)
# 9. End the synchronous section, continuing the remaining steps in parallel.
# 10. If URL is not the empty string, then:
if not ak.string_is_empty(&url):
# 1. Let request be the result of creating a potential-CORS request given URL, "track", and corsAttributeState,
# and with the same-origin fallback flag set.
let parsed_url = web_url.parser_basic_parse(ak.string_bytes_as_string_view(&url)) else trap("VERIFY: parsed_url.has_value()")
let request = html_create_potential_cors_request(realm_vm(realm), parsed_url, FetchRequestDestination.track, cors_attribute_state, HtmlSameOriginFallbackFlag.yes)
# 2. Set request's client to the track element's node document's relevant settings object.
fetch_request_set_client(request, dom_document_relevant_settings_object(dom_node_document(this.dom_node())))
# 3. Set request's initiator type to "track".
fetch_request_set_initiator_type(request, FetchRequestInitiatorType.track)
# 4. Fetch request.
let algorithms = fetch_algorithms_create(realm_vm(realm), FetchAlgorithmsInput(process_response_consume_body = ak.Function2[FetchResponse*, FetchAlgorithmsBodyBytes, unit](call = html_track_element_process_response_consume_body, context = this)))
this.m_fetch_algorithms = algorithms
this.m_fetch_controller = fetch_fetching_fetch(realm, request, algorithms)
else:
html_track_element_track_failed_to_load(this)
return
# 11. Wait until the text track readiness state is no longer set to loading.
if html_text_track_readiness_state(track) == HtmlTextTrackReadinessState.loading:
html_text_track_observer_set_track_readiness_observer(this.m_track_observer else trap("HTMLTrackElement: no observer"), ak.Function1[HtmlTextTrackReadinessState, unit](call = html_track_element_track_readiness_changed, context = this))
else:
html_track_element_track_became_ready(this)
## Ported from HTMLTrackElement.cpp:262 Web::HTML::HTMLTrackElement::track_became_ready.
pub func html_track_element_track_became_ready(this: HtmlTrackElement*):
html_text_track_observer_set_track_readiness_observer(this.m_track_observer else trap("HTMLTrackElement: no observer"), none)
# 12. Wait until the track URL is no longer equal to URL, at the same time as the text track mode is set to hidden or showing.
this.m_awaiting_track_url_change = true
## track_failed_to_load's task: `[this]() { ... }`.
func html_track_element_failed_to_load_task(context: void*?):
let this = (HtmlTrackElement*)(context else trap("failed to load task: no element"))
let realm = html_element_realm(this.html_element())
html_text_track_set_readiness_state(html_track_element_text_track(this), HtmlTextTrackReadinessState.failed_to_load)
_ = dom_event_target_dispatch_event(this.dom_event_target(), dom_event_create(realm, html_event_names_error))
## Ported from HTMLTrackElement.cpp:270 Web::HTML::HTMLTrackElement::track_failed_to_load.
pub func html_track_element_track_failed_to_load(this: HtmlTrackElement*):
_ = dom_element_queue_an_element_task(this.dom_element(), HtmlTaskSource.dom_manipulation, ak.Function0[unit](call = html_track_element_failed_to_load_task, context = this))