Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / html / html_media_element_1.lucb

#==============================================================================================
#
#   html_media_element_1 - HTML::HTMLMediaElement: construction, attributes, the media
#                          provider object, errors, time ranges and canPlayType
#
#   DESCRIPTION:
#       Port of LibWeb/HTML/HTMLMediaElement.cpp lines 59-397 and the inline members of
#       HTMLMediaElement.h: RemoteFetchData's destructor, the constructor (which moves the
#       mixin tables to the concrete class's, as C++'s vptrs move), initialize (the track
#       lists and the document observer), finalize, adjust_computed_style, queueing a media
#       element task, visit_edges, attribute_changed, srcObject and the assigned media provider
#       object, the removing steps, cancelling the fetching process, the fatal decode error
#       steps, buffered / played / seekable, canPlayType, seeking and load().
#
#       Media playback is phase 4 and loading phase 2 (DESIGN.md §1.4): what C++ asks of
#       AudioTrackList, VideoTrackList, TextTrackList, TimeRanges, MediaError and LibMedia goes
#       to the closure stubs of stub_closure's "Region r27 media" sections.
#
#==============================================================================================

# mark: Helpers =================================================================================

## The media element's realm (`this->realm()`).
func html_media_element_realm(this: HtmlMediaElement*) -> Realm*:
    return html_element_realm(this.html_element())

## The media element's node document (`document()`).
func html_media_element_document(this: HtmlMediaElement*) -> DomDocument*:
    return html_element_document(this.html_element())

## `dispatch_event(DOM::Event::create(realm(), event_name))` at the media element.
func html_media_element_fire_event(this: HtmlMediaElement*, event_name: ak.FlyString):
    _ = dom_event_target_dispatch_event(this.dom_event_target(), dom_event_create(html_media_element_realm(this), event_name))

## The captures of the many `queue_a_media_element_task([this] { dispatch_event(DOM::Event::create(realm(),
## HTML::EventNames::X)); })` lambdas: the element and the event's name.
struct HtmlMediaElementFireEventTask:
    var this: HtmlMediaElement*
    var event_name: ak.FlyString

    ## The task's steps: fire the event at the element.
    static func run(context: void*?):
        let captures = (HtmlMediaElementFireEventTask*)(context else trap("fire event task: no captures"))
        html_media_element_fire_event(captures.this, captures.event_name)

## `queue_a_media_element_task([this] { dispatch_event(DOM::Event::create(realm(), event_name)); })`.
func html_media_element_queue_firing_an_event(this: HtmlMediaElement*, event_name: ak.FlyString):
    let captures = new HtmlMediaElementFireEventTask(this = this, event_name = event_name) else trap("out of memory")
    html_media_element_queue_a_media_element_task(this, ak.Function0[unit](call = HtmlMediaElementFireEventTask.run, context = captures))

## `m_delaying_the_load_event.clear()`: destroys a held delayer (its destructor stops delaying the
## document's load event).
func html_media_element_clear_delaying_the_load_event(this: HtmlMediaElement*):
    if let delayer = this.m_delaying_the_load_event:
        var released = delayer
        dom_document_load_event_delayer_destruct(&released)
    this.m_delaying_the_load_event = none

## `m_delaying_the_load_event.emplace(document)`: the previous delayer, if any, is destroyed first.
func html_media_element_emplace_delaying_the_load_event(this: HtmlMediaElement*, document: DomDocument*):
    html_media_element_clear_delaying_the_load_event(this)
    var delayer: DomDocumentLoadEventDelayer = ---
    dom_document_load_event_delayer_construct(&delayer, document)
    this.m_delaying_the_load_event = delayer

## `style.display().is_contents()` → `display: none` (https://drafts.csswg.org/css-display-3/#unbox), the
## adjust_computed_style step every replaced-content element shares.
func html_media_element_set_display(style: CssComputedProperties*, short_: CssDisplayShort):
    css_computed_properties_set_property(style, css_data.PropertyId.display, css_display_style_value_create(css_display_from_short(short_)).css_style_value())

# mark: RemoteFetchData and construction ========================================================

## Ported from HTMLMediaElement.cpp:67 Web::HTML::HTMLMediaElement::RemoteFetchData::~RemoteFetchData.
## `m_remote_fetch_data.clear()` and every reassignment of the OwnPtr run it.
func html_media_element_remote_fetch_data_destruct(this: HtmlMediaElementRemoteFetchData*):
    if let stream = this.stream:
        media_incrementally_populated_stream_set_data_request_callback(stream, none)
        media_incrementally_populated_stream_close(stream)

    if let fetch_controller = (FetchController*?)gc.weak_ptr(&this.fetch_controller):
        fetch_controller_stop_fetch(fetch_controller)

## `m_remote_fetch_data.clear()`: the OwnPtr's destructor runs RemoteFetchData's.
func html_media_element_clear_remote_fetch_data(this: HtmlMediaElement*):
    if let fetch_data = this.m_remote_fetch_data:
        this.m_remote_fetch_data = none
        html_media_element_remote_fetch_data_destruct(fetch_data)

## Ported from HTMLMediaElement.cpp:79 Web::HTML::HTMLMediaElement::HTMLMediaElement.
pub func html_media_element_construct(this: HtmlMediaElement*, document: DomDocument*, qualified_name: DomQualifiedName):
    html_element_construct(this.html_element(), document, qualified_name)
    # The vptrs of the mixin bases move to HTMLMediaElement's tables.
    let element = this.html_element()
    element.element.slottable_mixin.vtable = &html_media_element_slottable_mixin_vtable
    element.element.aria_mixin.vtable = &html_media_element_aria_mixin_vtable
    element.element.animatable.vtable = &html_media_element_animatable_vtable
    element.global_event_handlers.vtable = &html_media_element_global_event_handlers_vtable
    element.form_associated_element.vtable = &html_media_element_form_associated_element_vtable
    # The members' initializers: the unique media element event task source and the non-zero
    # defaults (m_duration { NAN }).
    html_unique_task_source_construct(&this.m_media_element_event_task_source)
    html_media_element_init_fields(this)
    this.m_duration = math.nan

## The captures of initialize's document observer callbacks: the media element.
struct HtmlMediaElementDocumentObserverCallback:
    var this: HtmlMediaElement*

    ## `set_document_became_inactive`'s callback.
    static func became_inactive(context: void*?):
        let this = ((HtmlMediaElementDocumentObserverCallback*)(context else trap("document observer: no captures"))).this

        # If the media element's node document stops being a fully active document, then the playback will stop until
        # the document is active again.
        html_media_element_pause_element(this)

        # AD-HOC: Stop the fetch here so that the element can be reclaimed by GC. The fetch callbacks hold a strong
        #         reference to their media element to ensure that load/error events are fired as expected.
        if let fetch_data = this.m_remote_fetch_data:
            if let fetch_controller = (FetchController*?)gc.weak_ptr(&fetch_data.fetch_controller):
                fetch_controller_stop_fetch(fetch_controller)
                gc.weak_assign(&fetch_data.fetch_controller, none)

    ## `set_document_became_active`'s callback.
    static func became_active(context: void*?):
        let this = ((HtmlMediaElementDocumentObserverCallback*)(context else trap("document observer: no captures"))).this

        # AD-HOC: Restart the fetch from where the stream last received data so that playback can continue.
        if let fetch_data = this.m_remote_fetch_data:
            assert(gc.weak_ptr(&fetch_data.fetch_controller) == none)
            let stream = fetch_data.stream else trap("RemoteFetchData: no stream")
            # `next_chunk_start() != expected_size()`: a u64 against an Optional<u64>, unequal when it is empty.
            let expected_size = media_incrementally_populated_stream_expected_size(stream)
            if expected_size == none or media_incrementally_populated_stream_next_chunk_start(stream) != (expected_size else 0):
                html_media_element_load_remote_resource(this, .html_media_element_until_end(HtmlMediaElementUntilEnd(first = media_incrementally_populated_stream_next_chunk_start(stream))))

## Ported from HTMLMediaElement.cpp:86 Web::HTML::HTMLMediaElement::initialize (override).
pub func html_media_element_initialize_impl(base: JsCell*, realm: Realm*):
    let this = (HtmlMediaElement*)base
    web_set_prototype_for_interface(base, realm, BindInterfaceName.html_media_element)
    html_element_initialize_impl(base, realm)

    this.m_audio_tracks = realm_create_html_audio_track_list(realm, realm)
    this.m_video_tracks = realm_create_html_video_track_list(realm, realm, this)
    this.m_text_tracks = realm_create_html_text_track_list(realm, realm)
    let document_observer = realm_create_dom_document_observer(realm, realm, html_media_element_document(this))
    this.m_document_observer = document_observer

    let captures = new HtmlMediaElementDocumentObserverCallback(this = this) else trap("out of memory")

    # https://html.spec.whatwg.org/multipage/media.html#playing-the-media-resource:media-element-82
    dom_document_observer_set_document_became_inactive(document_observer, ak.Function0[unit](call = HtmlMediaElementDocumentObserverCallback.became_inactive, context = captures))

    dom_document_observer_set_document_became_active(document_observer, ak.Function0[unit](call = HtmlMediaElementDocumentObserverCallback.became_active, context = captures))

    page_register_media_element(dom_document_page(html_media_element_document(this)), dom_node_unique_id(this.dom_node()))

## Ported from HTMLMediaElement.cpp:122 Web::HTML::HTMLMediaElement::finalize (override).
pub func html_media_element_finalize_impl(base: gc.Cell*):
    let this = (HtmlMediaElement*)base
    dom_node_finalize_impl(base)

    page_unregister_media_element(dom_document_page(html_media_element_document(this)), dom_node_unique_id(this.dom_node()))

    # ~HTMLMediaElement destroys m_controls, whose hover timer (RefPtr<Core::Timer>) stops with it;
    # the port's controls outlive the element, so their timer stops here, or it would fire on
    # controls whose elements were collected. (Only the timer: the rest of the destructor reaches
    # other cells, which a finalizer must not.)
    if let controls = this.m_controls:
        if let hover_timer = controls.m_hover_timer:
            core_timer_stop(hover_timer)

## Ported from HTMLMediaElement.cpp:129 Web::HTML::HTMLMediaElement::adjust_computed_style (override).
pub func html_media_element_adjust_computed_style_impl(base: DomElement*, style: CssComputedProperties*):
    # https://drafts.csswg.org/css-display-3/#unbox
    let contents_display = css_computed_properties_display(style)
    if css_display_is_contents(&contents_display):
        html_media_element_set_display(style, CssDisplayShort.none_)

    # AD-HOC: We rewrite `display: inline` to `display: inline-block`.
    #         This is required for the internal shadow tree to work correctly in layout.
    let display = css_computed_properties_display(style)
    if css_display_is_inline_outside(&display) and css_display_is_flow_inside(&display):
        html_media_element_set_display(style, CssDisplayShort.inline_block)

## Ported from HTMLMediaElement.cpp:142 Web::HTML::HTMLMediaElement::queue_a_media_element_task.
# https://html.spec.whatwg.org/multipage/media.html#queue-a-media-element-task
pub func html_media_element_queue_a_media_element_task(this: HtmlMediaElement*, steps: ak.Function0[unit]):
    # To queue a media element task with a media element element and a series of steps steps, queue an element task on the media element's
    # media element event task source given element and steps.
    _ = dom_element_queue_an_element_task(this.dom_element(), html_media_element_media_element_event_task_source(this), steps)

## Ported from HTMLMediaElement.cpp:149 Web::HTML::HTMLMediaElement::visit_edges (override).
pub func html_media_element_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (HtmlMediaElement*)base
    html_element_visit_edges_impl(base, visitor)
    gc.cell_visitor_visit_cell(visitor, (gc.Cell*?)this.m_error)  # opaque in phase 1
    gc.cell_visitor_visit_cell(visitor, (gc.Cell*?)this.m_audio_tracks)  # opaque in phase 1
    gc.cell_visitor_visit_cell(visitor, (gc.Cell*?)this.m_video_tracks)  # opaque in phase 1
    gc.cell_visitor_visit_cell(visitor, (gc.Cell*?)this.m_text_tracks)  # opaque in phase 1
    gc.cell_visitor_visit_t[DomDocumentObserver](visitor, this.m_document_observer)
    gc.cell_visitor_visit_t[HtmlSourceElementSelector](visitor, this.m_source_element_selector)
    for promise in ak.vector_span(&this.m_pending_play_promises):  # m_pending_play_promises (opaque in phase 1)
        gc.cell_visitor_visit_cell(visitor, (gc.Cell*)promise)
    gc.cell_visitor_visit_cell(visitor, (gc.Cell*?)this.m_selected_video_track)  # opaque in phase 1
    match this.m_assigned_media_provider_object:
        .empty:
            return
        .media_source_extensions_media_source(media_source):
            gc.cell_visitor_visit_cell(visitor, (gc.Cell*)media_source)  # opaque in phase 1
        .file_api_blob(blob):
            gc.cell_visitor_visit_cell(visitor, (gc.Cell*)blob)  # opaque in phase 1

# mark: Attributes and the media provider object ================================================

## Ported from HTMLMediaElement.cpp:170 Web::HTML::HTMLMediaElement::attribute_changed (override).
pub func html_media_element_attribute_changed_impl(base: DomElement*, name: ak.FlyString, old_value: ak.String?, value: ak.String?, namespace_: ak.FlyString?):
    let this = (HtmlMediaElement*)base
    html_element_attribute_changed_impl(base, name, old_value, value, namespace_)

    if ak.fly_string_eq_fly_string(&name, &html_attribute_names_src):
        # https://html.spec.whatwg.org/multipage/media.html#attr-media-src
        # If a src attribute of a media element is set or changed, the user agent must invoke the
        # media element's media element load algorithm. (Removing the src attribute does not do
        # this, even if there are source elements present.)
        if value == none:
            return
        html_media_element_load_element(this) else trap("FIXME: should propagate errors")
    elif ak.fly_string_eq_fly_string(&name, &html_attribute_names_crossorigin):
        this.m_crossorigin = html_cors_setting_attribute_from_keyword(value)
    elif ak.fly_string_eq_fly_string(&name, &html_attribute_names_controls):
        if value != none or dom_node_is_scripting_disabled(this.dom_node()):
            html_media_element_create_controls(this)
        else:
            html_media_element_destroy_controls(this)

## Ported from HTMLMediaElement.cpp:193 Web::HTML::HTMLMediaElement::src_object.
# https://html.spec.whatwg.org/multipage/media.html#dom-media-srcobject
pub func html_media_element_src_object(this: HtmlMediaElement*) -> HtmlOptionalMediaProvider:
    # The srcObject IDL attribute, on getting, must return the element's assigned media provider
    # object, if any, or null otherwise.
    match html_media_element_assigned_media_provider_object_const(this):
        .empty:
            return .empty
        .file_api_blob(blob):
            return .file_api_blob(blob)
        .media_source_extensions_media_source(media_source):
            return .media_source_extensions_media_source(media_source)

## Ported from HTMLMediaElement.cpp:210 Web::HTML::HTMLMediaElement::set_src_object.
# https://html.spec.whatwg.org/multipage/media.html#dom-media-srcobject
pub func html_media_element_set_src_object(this: HtmlMediaElement*, src_object: HtmlOptionalMediaProvider) -> !:
    # On setting, it must set the element's assigned media provider object to the new value,
    var provider: HtmlMediaElementMediaProviderObject = .empty
    match src_object:
        .empty:
            provider = .empty
        .file_api_blob(blob):
            provider = .file_api_blob(blob else trap("GC::Ref of a null Blob root"))
        .media_source_extensions_media_source(media_source):
            provider = .media_source_extensions_media_source(media_source else trap("GC::Ref of a null MediaSource root"))
    html_media_element_set_assigned_media_provider_object(this, provider)

    # and then invoke the element's media element load algorithm.
    try html_media_element_load_element(this)

## Ported from HTMLMediaElement.cpp:228 Web::HTML::HTMLMediaElement::assigned_media_provider_object.
pub func html_media_element_assigned_media_provider_object(this: HtmlMediaElement*) -> HtmlMediaElementMediaProviderObject*:
    return &this.m_assigned_media_provider_object

## Ported from HTMLMediaElement.cpp:233 Web::HTML::HTMLMediaElement::assigned_media_provider_object.
pub func html_media_element_assigned_media_provider_object_const(this: HtmlMediaElement*) -> HtmlMediaElementMediaProviderObject:
    return this.m_assigned_media_provider_object

## Ported from HTMLMediaElement.cpp:238 Web::HTML::HTMLMediaElement::set_assigned_media_provider_object.
pub func html_media_element_set_assigned_media_provider_object(this: HtmlMediaElement*, provider: HtmlMediaElementMediaProviderObject):
    this.m_assigned_media_provider_object = provider

## Ported from HTMLMediaElement.cpp:244 Web::HTML::HTMLMediaElement::removed_from (override).
# https://html.spec.whatwg.org/multipage/media.html#playing-the-media-resource:media-element-83
pub func html_media_element_removed_from_impl(base: DomNode*, is_subtree_root: DomNodeIsSubtreeRoot, old_ancestor: DomNode*?, old_root: DomNode*):
    let this = (HtmlMediaElement*)base
    html_element_removed_from_impl(base, is_subtree_root, old_ancestor, old_root)

    # When a media element is removed from a Document, the user agent must run the following steps:

    # FIXME: 1. Await a stable state, allowing the task that removed the media element from the Document to continue. The
    #           synchronous section consists of all the remaining steps of this algorithm. (Steps in the synchronous section
    #           are marked with ⌛.)

    # 2. ⌛ If the media element is in a document, return.
    if dom_node_in_a_document_tree(base):
        return

    # 3. ⌛ Run the internal pause steps for the media element.
    html_media_element_pause_element(this)

# mark: Fetching and errors =====================================================================

## Ported from HTMLMediaElement.cpp:262 Web::HTML::HTMLMediaElement::cancel_the_fetching_process.
pub func html_media_element_cancel_the_fetching_process(this: HtmlMediaElement*):
    this.m_current_fetch_generation +%= 1
    if let fetch_data = this.m_remote_fetch_data:
        if let stream = fetch_data.stream:
            media_incrementally_populated_stream_close(stream)
    html_media_element_clear_remote_fetch_data(this)

## Ported from HTMLMediaElement.cpp:271 Web::HTML::HTMLMediaElement::set_decoder_error.
# https://html.spec.whatwg.org/multipage/media.html#fatal-decode-error
pub func html_media_element_set_decoder_error(this: HtmlMediaElement*, error_message: ak.String):
    let realm = html_media_element_realm(this)

    if this.m_error != none:
        return

    # -> If the media data is corrupted

    # Fatal errors in decoding the media data that occur after the user agent has established whether the current media
    # resource is usable (i.e. once the media element's readyState attribute is no longer HAVE_NOTHING) must cause the
    # user agent to execute the following steps:

    # NB: This is only invoked by PlaybackManager after the metadata has been retrieved, so we should be sure that
    #     the ready state indicates we have that metadata.
    assert(this.m_ready_state != HtmlMediaElementReadyState.have_nothing)

    # 1. The user agent should cancel the fetching process.
    html_media_element_cancel_the_fetching_process(this)

    # 2. Set the error attribute to the result of creating a MediaError with MEDIA_ERR_DECODE.
    this.m_error = realm_create_html_media_error(realm, realm, HtmlMediaErrorCode.decode, error_message)

    # 3. Set the element's networkState attribute to the NETWORK_IDLE value.
    this.m_network_state = HtmlMediaElementNetworkState.idle

    # 4. Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
    html_media_element_clear_delaying_the_load_event(this)

    # 5. Fire an event named error at the media element.
    html_media_element_fire_event(this, html_event_names_error)

    # 6. Abort the overall resource selection algorithm.
    # NB: Cancelling the fetching process stops the resource selection algorithm when the error is set.

# mark: Time ranges and canPlayType =============================================================

## Ported from HTMLMediaElement.cpp:308 Web::HTML::HTMLMediaElement::buffered.
# https://html.spec.whatwg.org/multipage/media.html#dom-media-buffered
pub func html_media_element_buffered(this: HtmlMediaElement*) -> HtmlTimeRanges*:
    let realm = html_media_element_realm(this)

    # https://html.spec.whatwg.org/multipage/media.html#dom-media-buffered
    # The buffered attribute must return a new static normalized TimeRanges object that represents the ranges of the
    # media resource, if any, that the user agent has buffered, at the time the attribute is evaluated.
    let time_ranges = realm_create_html_time_ranges(realm, realm)
    if let playback_manager = this.m_playback_manager:
        let ranges = media_playback_manager_buffered_time_ranges(playback_manager)
        for range in ak.vector_span_const(&ranges.ranges):
            html_time_ranges_add_range(time_ranges, ak.duration_to_seconds_f64(&range.start), ak.duration_to_seconds_f64(&range.end))
    return time_ranges

## Ported from HTMLMediaElement.cpp:324 Web::HTML::HTMLMediaElement::played.
# https://html.spec.whatwg.org/multipage/media.html#dom-media-played
pub func html_media_element_played(this: HtmlMediaElement*) -> HtmlTimeRanges*:
    let realm = html_media_element_realm(this)

    # The played attribute must return a new static normalized TimeRanges object that represents the ranges of points on the media timeline of the media resource reached through the
    # usual monotonic increase of the current playback position during normal playback, if any, at the time the attribute is evaluated.
    let time_ranges = realm_create_html_time_ranges(realm, realm)
    # FIXME: Actually add the correct ranges
    return time_ranges

## Ported from HTMLMediaElement.cpp:336 Web::HTML::HTMLMediaElement::seekable.
# https://html.spec.whatwg.org/multipage/media.html#dom-media-seekable
pub func html_media_element_seekable(this: HtmlMediaElement*) -> HtmlTimeRanges*:
    let realm = html_media_element_realm(this)

    # The seekable attribute must return a new static normalized TimeRanges object that represents the ranges of the media resource, if any, that the
    # user agent is able to seek to, at the time the attribute is evaluated.
    let time_ranges = realm_create_html_time_ranges(realm, realm)
    html_time_ranges_add_range(time_ranges, 0.0, this.m_duration)
    return time_ranges

## Whether one of `subtypes` is `subtype` (`Array::contains_slow`).
func html_media_element_subtypes_contain(subtypes: const str[], subtype: ak.String) -> bool:
    for candidate in subtypes:
        if ak.string_eq_string_view(&subtype, ak.sv(candidate)):
            return true
    return false

## Ported from HTMLMediaElement.cpp:348 Web::HTML::HTMLMediaElement::can_play_type.
# https://html.spec.whatwg.org/multipage/media.html#dom-navigator-canplaytype
pub func html_media_element_can_play_type(this: HtmlMediaElement*, type_: ak.StringView) -> BindCanPlayTypeResult:
    # The canPlayType(type) method must:
    # - return the empty string if type is a type that the user agent knows it cannot render or is the type "application/octet-stream"
    # - return "probably" if the user agent is confident that the type represents a media resource that it can render if used in with this audio or video element
    # - return "maybe" otherwise. Implementers are encouraged to return "maybe" unless the type can be confidently established as being supported or not
    # Generally, a user agent should never return "probably" for a type that allows the codecs parameter if that parameter is not present.
    let type_view = type_
    if ak.string_view_eq_string_view(&type_view, ak.sv("application/octet-stream")):
        return BindCanPlayTypeResult.empty

    let mime_type = mime_type_parse(type_)

    if let parsed = mime_type:
        let parsed_type = mime_type_type(&parsed)
        if ak.string_eq_string_view(&parsed_type, ak.sv("video")):
            if html_media_element_subtypes_contain(html_media_element_supported_video_subtypes, mime_type_subtype(&parsed)):
                return BindCanPlayTypeResult.probably
            return BindCanPlayTypeResult.maybe

    if let parsed = mime_type:
        let parsed_type = mime_type_type(&parsed)
        if ak.string_eq_string_view(&parsed_type, ak.sv("audio")):
            var result = BindCanPlayTypeResult.maybe
            if html_media_element_subtypes_contain(html_media_element_supported_audio_subtypes, mime_type_subtype(&parsed)):
                result = BindCanPlayTypeResult.probably

            # "Maybe" because we support mp3, but "mpeg" can also refer to MP1 and MP2.
            let parsed_subtype = mime_type_subtype(&parsed)
            if ak.string_eq_string_view(&parsed_subtype, ak.sv("mpeg")):
                result = BindCanPlayTypeResult.maybe

            return result

    return BindCanPlayTypeResult.empty

## Ported from HTMLMediaElement.cpp:381 Web::HTML::HTMLMediaElement::set_seeking.
pub func html_media_element_set_seeking(this: HtmlMediaElement*, seeking: bool):
    if this.m_seeking == seeking:
        return
    this.m_seeking = seeking
    dom_node_set_needs_style_update(this.dom_node(), true)

## Ported from HTMLMediaElement.cpp:390 Web::HTML::HTMLMediaElement::load.
# https://html.spec.whatwg.org/multipage/media.html#dom-media-load
pub func html_media_element_load(this: HtmlMediaElement*) -> !:
    # When the load() method on a media element is invoked, the user agent must run the media element load algorithm.
    try html_media_element_load_element(this)
    return

# mark: Inline members of HTMLMediaElement.h ====================================================

## Ported from HTMLMediaElement.h:47 Web::HTML::HTMLMediaElement::is_focusable (override).
pub func html_media_element_is_focusable_impl(base: DomEventTarget*) -> bool:
    return true

## Ported from HTMLMediaElement.h:56 Web::HTML::HTMLMediaElement::error.
pub func html_media_element_error(this: HtmlMediaElement*) -> HtmlMediaError*?:
    return this.m_error

## Ported from HTMLMediaElement.h:59 Web::HTML::HTMLMediaElement::current_src.
pub func html_media_element_current_src(this: HtmlMediaElement*) -> ak.String:
    return this.m_current_src

## Ported from HTMLMediaElement.h:71 Web::HTML::HTMLMediaElement::network_state.
pub func html_media_element_network_state(this: HtmlMediaElement*) -> HtmlMediaElementNetworkState:
    return this.m_network_state

## Ported from HTMLMediaElement.h:100 Web::HTML::HTMLMediaElement::ready_state.
pub func html_media_element_ready_state(this: HtmlMediaElement*) -> HtmlMediaElementReadyState:
    return this.m_ready_state

## Ported from HTMLMediaElement.h:104 Web::HTML::HTMLMediaElement::seeking.
pub func html_media_element_seeking(this: HtmlMediaElement*) -> bool:
    return this.m_seeking

## Ported from HTMLMediaElement.h:113 Web::HTML::HTMLMediaElement::current_playback_position.
pub func html_media_element_current_playback_position(this: HtmlMediaElement*) -> f64:
    return this.m_current_playback_position

## Ported from HTMLMediaElement.h:117 Web::HTML::HTMLMediaElement::show_poster.
pub func html_media_element_show_poster(this: HtmlMediaElement*) -> bool:
    return this.m_show_poster

## Ported from HTMLMediaElement.h:118 Web::HTML::HTMLMediaElement::paused.
pub func html_media_element_paused(this: HtmlMediaElement*) -> bool:
    return this.m_paused

## Ported from HTMLMediaElement.h:125 Web::HTML::HTMLMediaElement::volume.
pub func html_media_element_volume(this: HtmlMediaElement*) -> f64:
    return this.m_volume

## Ported from HTMLMediaElement.h:128 Web::HTML::HTMLMediaElement::default_playback_rate.
pub func html_media_element_default_playback_rate(this: HtmlMediaElement*) -> f64:
    return this.m_default_playback_rate

## Ported from HTMLMediaElement.h:131 Web::HTML::HTMLMediaElement::playback_rate.
pub func html_media_element_playback_rate(this: HtmlMediaElement*) -> f64:
    return this.m_playback_rate

## Ported from HTMLMediaElement.h:134 Web::HTML::HTMLMediaElement::muted.
pub func html_media_element_muted(this: HtmlMediaElement*) -> bool:
    return this.m_muted

## Ported from HTMLMediaElement.h:143 Web::HTML::HTMLMediaElement::audio_tracks.
pub func html_media_element_audio_tracks(this: HtmlMediaElement*) -> HtmlAudioTrackList*:
    return this.m_audio_tracks else trap("HTMLMediaElement::audio_tracks before initialize")

## Ported from HTMLMediaElement.h:144 Web::HTML::HTMLMediaElement::video_tracks.
pub func html_media_element_video_tracks(this: HtmlMediaElement*) -> HtmlVideoTrackList*:
    return this.m_video_tracks else trap("HTMLMediaElement::video_tracks before initialize")

## Ported from HTMLMediaElement.h:145 Web::HTML::HTMLMediaElement::text_tracks.
pub func html_media_element_text_tracks(this: HtmlMediaElement*) -> HtmlTextTrackList*:
    return this.m_text_tracks else trap("HTMLMediaElement::text_tracks before initialize")

## Ported from HTMLMediaElement.h:157 Web::HTML::HTMLMediaElement::set_duration (Badge<MediaSource>).
pub func html_media_element_set_duration_media_source(this: HtmlMediaElement*, duration: f64):
    html_media_element_set_duration_f64(this, duration)

## Ported from HTMLMediaElement.h:159 Web::HTML::HTMLMediaElement::playback_manager.
pub func html_media_element_playback_manager(this: HtmlMediaElement*) -> MediaPlaybackManager*:
    return this.m_playback_manager else trap("VERIFY: m_playback_manager")

## Ported from HTMLMediaElement.h:168 Web::HTML::HTMLMediaElement::crossorigin.
pub func html_media_element_crossorigin(this: HtmlMediaElement*) -> HtmlCorsSettingAttribute:
    return this.m_crossorigin

## Ported from HTMLMediaElement.h:170 Web::HTML::HTMLMediaElement::selected_video_track_sink.
pub func html_media_element_selected_video_track_sink(this: HtmlMediaElement*) -> MediaDisplayingVideoSink*?:
    return this.m_selected_video_track_sink

## Ported from HTMLMediaElement.h:174 Web::HTML::HTMLMediaElement::update_intrinsic_video_dimensions (virtual).
pub func html_media_element_update_intrinsic_video_dimensions_impl(this: HtmlMediaElement*):
    return

## Ported from HTMLMediaElement.h:175 Web::HTML::HTMLMediaElement::update_natural_dimensions (virtual).
pub func html_media_element_update_natural_dimensions_impl(this: HtmlMediaElement*):
    return

## Ported from HTMLMediaElement.h:193 Web::HTML::HTMLMediaElement::is_html_media_element (override).
pub func html_media_element_is_html_media_element_impl(base: DomNode*) -> bool:
    return true

## Ported from HTMLMediaElement.h:201 Web::HTML::HTMLMediaElement::media_element_event_task_source.
pub func html_media_element_media_element_event_task_source(this: HtmlMediaElement*) -> HtmlTaskSource:
    return this.m_media_element_event_task_source.source

## Ported from HTMLMediaElement.h:274 Web::HTML::HTMLMediaElement::reject_pending_play_promises<ErrorType>.
# https://html.spec.whatwg.org/multipage/media.html#reject-pending-play-promises
# The C++ template parameter ErrorType (WebIDL::AbortError, WebIDL::NotSupportedError) is the
# function `create_error`, the type's create.
pub func html_media_element_reject_pending_play_promises_utf16_string(this: HtmlMediaElement*, promises: const (JsPromiseCapability*)[], message: ak.Utf16String, create_error: func(Realm*, ak.Utf16String) -> IdlDomException*):
    let realm = html_media_element_realm(this)

    let error_ = create_error(realm, message)
    html_media_element_reject_pending_play_promises_idl_dom_exception(this, promises, error_)