Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / 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))