Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / html / html_iframe_element.lucb

#==============================================================================================
#
#   html_iframe_element - HTML::HTMLIFrameElement: <iframe>
#
#   DESCRIPTION:
#       Port of LibWeb/HTML/HTMLIFrameElement.cpp (lines 1-325) and the inlines of
#       HTMLIFrameElement.h (with LAZY_LOADING_ELEMENT's two overrides): construction (which
#       moves the mixin tables to HTMLIFrameElement's, as C++'s vptrs move), initialize, the
#       NavigableContainerViewport layout node, the display adjustment, attribute_changed, the
#       post-connection and removal steps, processing the iframe attributes (with its lazy
#       loading resumption steps), the iframe load event steps, the frameborder presentational
#       hint, sandbox and srcdoc.
#
#==============================================================================================

# mark: HTMLIFrameElement.cpp ====================================================================

## Ported from HTMLIFrameElement.cpp:30 Web::HTML::HTMLIFrameElement::HTMLIFrameElement.
pub func html_htmli_frame_element_construct(this: HtmlHtmliFrameElement*, document: DomDocument*, qualified_name: DomQualifiedName):
    html_navigable_container_construct(&this.navigable_container, document, qualified_name)
    # The vptrs of the mixin bases move to HTMLIFrameElement's tables. (The LazyLoadingElement
    # base starts with no resumption steps.)
    let element = this.html_element()
    element.element.slottable_mixin.vtable = &html_htmli_frame_element_slottable_mixin_vtable
    element.element.aria_mixin.vtable = &html_htmli_frame_element_aria_mixin_vtable
    element.element.animatable.vtable = &html_htmli_frame_element_animatable_vtable
    element.global_event_handlers.vtable = &html_htmli_frame_element_global_event_handlers_vtable
    element.form_associated_element.vtable = &html_htmli_frame_element_form_associated_element_vtable

## Ported from HTMLIFrameElement.cpp:37 Web::HTML::HTMLIFrameElement::initialize (override).
pub func html_htmli_frame_element_initialize_impl(base: JsCell*, realm: Realm*):
    web_set_prototype_for_interface(base, realm, BindInterfaceName.htmli_frame_element)
    html_element_initialize_impl(base, realm)

## Ported from HTMLIFrameElement.cpp:43 Web::HTML::HTMLIFrameElement::create_layout_node (override).
pub func html_htmli_frame_element_create_layout_node_impl(base: DomElement*, style: CssComputedProperties*) -> LayoutNode*?:
    let this = (HtmlHtmliFrameElement*)base
    # heap().allocate<Layout::NavigableContainerViewport>(...): a layout node's initialize is JS::Cell's, which does nothing.
    return realm_create_layout_navigable_container_viewport(dom_element_realm(base), dom_node_document(base.dom_node()), &this.navigable_container, style).layout_node()

## Ported from HTMLIFrameElement.cpp:48 Web::HTML::HTMLIFrameElement::adjust_computed_style (override).
pub func html_htmli_frame_element_adjust_computed_style_impl(base: DomElement*, style: CssComputedProperties*):
    # https://drafts.csswg.org/css-display-3/#unbox
    let display = css_computed_properties_display(style)
    if css_display_is_contents(&display):
        css_computed_properties_set_property(style, css_data.PropertyId.display, css_display_style_value_create(css_display_from_short(CssDisplayShort.none_)).css_style_value())

## Ported from HTMLIFrameElement.cpp:55 Web::HTML::HTMLIFrameElement::attribute_changed (override).
pub func html_htmli_frame_element_attribute_changed_impl(base: DomElement*, name: ak.FlyString, old_value: ak.String?, value: ak.String?, namespace_: ak.FlyString?):
    let this = (HtmlHtmliFrameElement*)base
    html_element_attribute_changed_impl(base, name, old_value, value, namespace_)

    if html_name_is(name, html_attribute_names_sandbox):
        if let sandbox = this.m_sandbox:
            let value_or_empty = value else ak.string_new()
            dom_token_list_associated_attribute_changed(sandbox, ak.string_bytes_as_string_view(&value_or_empty))

    # https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element:process-the-iframe-attributes-2
    # https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element:process-the-iframe-attributes-3
    # Whenever an iframe element with a non-null content navigable has its srcdoc attribute set, changed, or removed,
    # the user agent must process the iframe attributes.
    # Similarly, whenever an iframe element with a non-null content navigable but with no srcdoc attribute specified
    # has its src attribute set, changed, or removed, the user agent must process the iframe attributes.
    if this.navigable_container.m_content_navigable != none:
        if html_name_is(name, html_attribute_names_srcdoc) or (html_name_is(name, html_attribute_names_src) and not dom_element_has_attribute(base, html_attribute_names_srcdoc)):
            html_htmli_frame_element_process_the_iframe_attributes(this)

        # https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element:iframe-sandboxing-flag-set-2
        # https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element:iframe-sandboxing-flag-set-3
        # When an iframe element's sandbox attribute is set or changed while it has a non-null content navigable, the
        # user agent must parse the sandboxing directive given the attribute's value and the iframe element's iframe
        # sandboxing flag set.
        # When an iframe element's sandbox attribute is removed while it has a non-null content navigable, the user
        # agent must empty the iframe element's iframe sandboxing flag set.
        if html_name_is(name, html_attribute_names_sandbox):
            if let present = value:
                this.m_iframe_sandboxing_flag_set = html_parse_a_sandboxing_directive(ak.KeyPath.string(present))
            else:
                this.m_iframe_sandboxing_flag_set = (HtmlSandboxingFlagSet)0

    if html_name_is(name, html_attribute_names_width) or html_name_is(name, html_attribute_names_height):
        css_invalidation_invalidate_style_after_embedded_content_geometry_change(base)

    if html_name_is(name, html_attribute_names_marginwidth) or html_name_is(name, html_attribute_names_marginheight):
        if let document = html_navigable_container_content_document_without_origin_check(&this.navigable_container):
            if let body_element = dom_document_body(document):
                dom_node_set_needs_style_update(body_element.dom_node(), true)

## Ported from HTMLIFrameElement.cpp:102 Web::HTML::HTMLIFrameElement::post_connection (override).
# https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element:html-element-post-connection-steps
pub func html_htmli_frame_element_post_connection_impl(base: DomNode*):
    let this = (HtmlHtmliFrameElement*)base
    let document = as_dom_document(dom_node_shadow_including_root(base))

    # NOTE: The check for "not fully active" is to prevent a crash on the dom/nodes/node-appendchild-crash.html WPT test.
    if dom_document_browsing_context(document) == none or not dom_document_is_fully_active(document):
        return

    # 1. If insertedNode has a sandbox attribute, then parse the sandboxing directive given the attribute's
    #    value and insertedNode's iframe sandboxing flag set.
    if let sandbox = dom_element_attribute(this.dom_element(), html_attribute_names_sandbox):
        this.m_iframe_sandboxing_flag_set = html_parse_a_sandboxing_directive(ak.KeyPath.string(sandbox))

    # 2. Create a new child navigable for insertedNode.
    html_navigable_container_create_new_child_navigable(&this.navigable_container)

    # 3. Process the iframe attributes for insertedNode, with initialInsertion set to true.
    html_htmli_frame_element_process_the_iframe_attributes(this, HtmlInitialInsertion.yes)

## The captures of process_the_iframe_attributes' srcdoc resumption steps: `[this]`.
struct HtmlHtmliFrameElementProcessTheIframeAttributesSrcdocSteps:
    var this: HtmlHtmliFrameElement*

## process_the_iframe_attributes' srcdoc resumption steps.
func html_htmli_frame_element_navigate_to_the_srcdoc_resource(context: void*?):
    let captures = (HtmlHtmliFrameElementProcessTheIframeAttributesSrcdocSteps*)(context else trap("lazy load resumption steps: no captures"))
    let this = captures.this
    # 3. Navigate to the srcdoc resource: navigate an iframe or frame given element, about:srcdoc, the empty string, and the value of element's srcdoc attribute.
    html_navigable_container_navigate_an_iframe_or_frame(&this.navigable_container, web_url.about_srcdoc(), ReferrerPolicyReferrerPolicy.empty_string, dom_element_get_attribute(this.dom_element(), html_attribute_names_srcdoc))

    # FIXME: The resulting Document must be considered an iframe srcdoc document.

## The captures of process_the_iframe_attributes' navigate resumption steps: `[this, url, referrer_policy]`.
struct HtmlHtmliFrameElementProcessTheIframeAttributesNavigateSteps:
    var this: HtmlHtmliFrameElement*
    var url: web_url.Url
    var referrer_policy: ReferrerPolicyReferrerPolicy

## process_the_iframe_attributes' navigate resumption steps.
func html_htmli_frame_element_navigate(context: void*?):
    let captures = (HtmlHtmliFrameElementProcessTheIframeAttributesNavigateSteps*)(context else trap("lazy load resumption steps: no captures"))
    # 7. Navigate: navigate an iframe or frame given element, url, and referrerPolicy.
    html_navigable_container_navigate_an_iframe_or_frame(&captures.this.navigable_container, captures.url, captures.referrer_policy)

## Ported from HTMLIFrameElement.cpp:123 Web::HTML::HTMLIFrameElement::process_the_iframe_attributes.
# https://html.spec.whatwg.org/multipage/iframe-embed-object.html#process-the-iframe-attributes
pub func html_htmli_frame_element_process_the_iframe_attributes(this: HtmlHtmliFrameElement*, initial_insertion: HtmlInitialInsertion = HtmlInitialInsertion.no):
    if html_navigable_container_content_navigable(&this.navigable_container) == none:
        return

    # 1. If element's srcdoc attribute is specified, then:
    if dom_element_has_attribute(this.dom_element(), html_attribute_names_srcdoc):
        # 1. Set element's current navigation was lazy loaded boolean to false.
        html_htmli_frame_element_set_current_navigation_was_lazy_loaded(this, false)

        # 2. If the will lazy load element steps given element return true, then:
        if html_lazy_loading_element_will_lazy_load_element(this):
            # 1. Set element's lazy load resumption steps to the rest of this algorithm starting with the step labeled navigate to the srcdoc resource.
            let captures = new HtmlHtmliFrameElementProcessTheIframeAttributesSrcdocSteps(this = this) else trap("out of memory")
            html_lazy_loading_element_set_lazy_load_resumption_steps(this, ak.Function0[unit](call = html_htmli_frame_element_navigate_to_the_srcdoc_resource, context = captures))

            # 2. Set element's current navigation was lazy loaded boolean to true.
            html_htmli_frame_element_set_current_navigation_was_lazy_loaded(this, true)

            # 3. Start intersection-observing a lazy loading element for element.
            dom_document_start_intersection_observing_a_lazy_loading_element(dom_node_document(this.dom_node()), this.dom_element())

            # 4. Return.
            return

        # 3. Navigate to the srcdoc resource: navigate an iframe or frame given element, about:srcdoc, the empty string, and the value of element's srcdoc attribute.
        html_navigable_container_navigate_an_iframe_or_frame(&this.navigable_container, web_url.about_srcdoc(), ReferrerPolicyReferrerPolicy.empty_string, dom_element_get_attribute(this.dom_element(), html_attribute_names_srcdoc))

        # FIXME: The resulting Document must be considered an iframe srcdoc document.

        return

    # 1. Let url be the result of running the shared attribute processing steps for iframe and frame elements given element and initialInsertion.
    let maybe_url = html_navigable_container_shared_attribute_processing_steps_for_iframe_and_frame(&this.navigable_container, initial_insertion)

    # 2. If url is null, then return.
    let url = maybe_url else return

    # 3. If url matches about:blank and initialInsertion is true, then:
    if html_url_matches_about_blank(url) and initial_insertion == HtmlInitialInsertion.yes:
        # 1. Run the iframe load event steps given element.
        html_run_iframe_load_event_steps(this)

        # 2. Return.
        return

    # 4. Let referrerPolicy be the current state of element's referrerpolicy content attribute.
    let referrer_policy_attribute = dom_element_get_attribute_value(this.dom_element(), html_attribute_names_referrerpolicy)
    let referrer_policy = referrer_policy_from_string(ak.string_bytes_as_string_view(&referrer_policy_attribute)) else ReferrerPolicyReferrerPolicy.empty_string

    # 5. Set element's current navigation was lazy loaded boolean to false.
    html_htmli_frame_element_set_current_navigation_was_lazy_loaded(this, false)

    # 6. If the will lazy load element steps given element return true, then:
    if html_lazy_loading_element_will_lazy_load_element(this):
        # 1. Set element's lazy load resumption steps to the rest of this algorithm starting with the step labeled navigate.
        let captures = new HtmlHtmliFrameElementProcessTheIframeAttributesNavigateSteps(this = this, url = url, referrer_policy = referrer_policy) else trap("out of memory")
        html_lazy_loading_element_set_lazy_load_resumption_steps(this, ak.Function0[unit](call = html_htmli_frame_element_navigate, context = captures))

        # 2. Set element's current navigation was lazy loaded boolean to true.
        html_htmli_frame_element_set_current_navigation_was_lazy_loaded(this, true)

        # 3. Start intersection-observing a lazy loading element for element.
        dom_document_start_intersection_observing_a_lazy_loading_element(dom_node_document(this.dom_node()), this.dom_element())

        # 4. Return.
        return

    # 7. Navigate: navigate an iframe or frame given element, url, and referrerPolicy.
    html_navigable_container_navigate_an_iframe_or_frame(&this.navigable_container, url, referrer_policy)

## Ported from HTMLIFrameElement.cpp:207 Web::HTML::HTMLIFrameElement::removed_from (override).
# https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element:the-iframe-element-7
pub func html_htmli_frame_element_removed_from_impl(base: DomNode*, is_subtree_root: DomNodeIsSubtreeRoot, old_ancestor: DomNode*?, old_root: DomNode*):
    let this = (HtmlHtmliFrameElement*)base
    html_element_removed_from_impl(base, is_subtree_root, old_ancestor, old_root)

    # When an iframe element is removed from a document, the user agent must destroy the nested navigable of the element.
    html_navigable_container_destroy_the_child_navigable(&this.navigable_container)

## Ported from HTMLIFrameElement.cpp:216 Web::HTML::run_iframe_load_event_steps.
# https://html.spec.whatwg.org/multipage/iframe-embed-object.html#iframe-load-event-steps
pub func html_run_iframe_load_event_steps(element: HtmlHtmliFrameElement*):
    # FIXME: 1. Assert: element's content navigable is not null.
    let content_navigable = html_navigable_container_content_navigable(&element.navigable_container)
    if content_navigable == none:
        # FIXME: For some reason, we sometimes end up here in the middle of SunSpider.
        ak.dbgln("FIXME: run_iframe_load_event_steps called with null nested browsing context")
        return

    # 2. Let childDocument be element's content navigable's active document.
    _ = html_navigable_active_document(content_navigable else trap("unreachable"))

    # FIXME: 3. If childDocument has its mute iframe load flag set, then return.

    # FIXME: 4. Set childDocument's iframe load in progress flag.

    # 5. Fire an event named load at element.
    _ = dom_event_target_dispatch_event(element.dom_event_target(), dom_event_create(dom_element_realm(element.dom_element()), html_event_names_load))

    # FIXME: 6. Unset childDocument's iframe load in progress flag.

## Ported from HTMLIFrameElement.cpp:239 Web::HTML::HTMLIFrameElement::default_tab_index_value (override).
# https://html.spec.whatwg.org/multipage/interaction.html#dom-tabindex
pub func html_htmli_frame_element_default_tab_index_value_impl(base: DomElement*) -> i32:
    # See the base function for the spec comments.
    return 0

## Ported from HTMLIFrameElement.cpp:245 Web::HTML::HTMLIFrameElement::is_presentational_hint (override).
pub func html_htmli_frame_element_is_presentational_hint_impl(base: DomElement*, name: ak.FlyString) -> bool:
    if dom_element_is_presentational_hint_impl(base, name):
        return true

    return html_name_is(name, html_attribute_names_frameborder)

## Ported from HTMLIFrameElement.cpp:253 Web::HTML::HTMLIFrameElement::apply_presentational_hints (override).
pub func html_htmli_frame_element_apply_presentational_hints_impl(base: DomElement*, properties: ak.Vector[CssStyleProperty]*):
    dom_element_apply_presentational_hints_impl(base, properties)

    # https://html.spec.whatwg.org/multipage/rendering.html#attributes-for-embedded-content-and-images:attr-iframe-frameborder
    # When an iframe element has a frameborder attribute whose value, when parsed using the rules for parsing integers,
    # is zero or an error, the user agent is expected to have presentational hints setting the element's
    # 'border-top-width', 'border-right-width', 'border-bottom-width', and 'border-left-width' properties to zero.
    if let frameborder_attribute = dom_element_get_attribute(base, html_attribute_names_frameborder):
        let frameborder = html_parse_integer(ak.string_bytes_as_string_view(&frameborder_attribute))
        if frameborder == none or frameborder == 0:
            let zero = css_length_style_value_create(css_length_make_px_f64(0.0)).css_style_value()
            html_append_presentational_hint(properties, css_data.PropertyId.border_top_width, zero)
            html_append_presentational_hint(properties, css_data.PropertyId.border_right_width, zero)
            html_append_presentational_hint(properties, css_data.PropertyId.border_bottom_width, zero)
            html_append_presentational_hint(properties, css_data.PropertyId.border_left_width, zero)

## Ported from HTMLIFrameElement.cpp:274 Web::HTML::HTMLIFrameElement::sandbox.
# https://html.spec.whatwg.org/multipage/iframe-embed-object.html#dom-iframe-sandbox
pub func html_htmli_frame_element_sandbox(this: HtmlHtmliFrameElement*) -> DomTokenList*:
    # The sandbox IDL attribute must reflect the sandbox content attribute.
    if this.m_sandbox == none:
        this.m_sandbox = dom_token_list_create(this.dom_element(), html_attribute_names_sandbox)
    return this.m_sandbox else trap("unreachable")

## Ported from HTMLIFrameElement.cpp:282 Web::HTML::HTMLIFrameElement::visit_edges (override).
pub func html_htmli_frame_element_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (HtmlHtmliFrameElement*)base
    html_navigable_container_visit_edges_impl(base, visitor)
    html_lazy_loading_element_visit_lazy_loading_element(this, visitor)
    gc.cell_visitor_visit_t[DomTokenList](visitor, this.m_sandbox)

## Ported from HTMLIFrameElement.cpp:289 Web::HTML::HTMLIFrameElement::set_current_navigation_was_lazy_loaded.
pub func html_htmli_frame_element_set_current_navigation_was_lazy_loaded(this: HtmlHtmliFrameElement*, value: bool):
    this.m_current_navigation_was_lazy_loaded = value

    # An iframe element whose current navigation was lazy loaded boolean is false potentially delays the load event.
    # https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element:potentially-delays-the-load-event
    html_navigable_container_set_potentially_delays_the_load_event(&this.navigable_container, not value)

## Ported from HTMLIFrameElement.cpp:299 Web::HTML::HTMLIFrameElement::srcdoc.
# https://html.spec.whatwg.org/multipage/iframe-embed-object.html#dom-iframe-srcdoc
pub func html_htmli_frame_element_srcdoc(this: HtmlHtmliFrameElement*) -> TrustedTypesTrustedHtmlOrString:
    # 1. Let attribute be the result of running get an attribute by namespace and local name given null, srcdoc's
    #    local name, and this.
    # 2. If attribute is null, then return the empty string.
    # 3. Return attribute's value.
    let value = dom_element_get_attribute_value(this.dom_element(), html_attribute_names_srcdoc)
    return TrustedTypesTrustedHtmlOrString.utf16_string(ak.utf16_string_from_utf8_string(&value))

## The implicit conversion of a TrustedHTMLOrString to get_trusted_type_compliant_string's input
## variant (TrustedHTML, TrustedScript, TrustedScriptURL or Utf16String).
func html_htmli_frame_element_trusted_type_input(value: TrustedTypesTrustedHtmlOrString) -> TrustedTypesTrustedHtmlOrTrustedTypesTrustedScriptOrTrustedTypesTrustedScriptUrlOrUtf16String:
    match value:
        .trusted_types_trusted_html(html):
            return TrustedTypesTrustedHtmlOrTrustedTypesTrustedScriptOrTrustedTypesTrustedScriptUrlOrUtf16String.trusted_types_trusted_html(html)
        .utf16_string(string):
            return TrustedTypesTrustedHtmlOrTrustedTypesTrustedScriptOrTrustedTypesTrustedScriptUrlOrUtf16String.utf16_string(string)

## Ported from HTMLIFrameElement.cpp:309 Web::HTML::HTMLIFrameElement::set_srcdoc.
# https://html.spec.whatwg.org/multipage/iframe-embed-object.html#dom-iframe-srcdoc
pub func html_htmli_frame_element_set_srcdoc(this: HtmlHtmliFrameElement*, value: TrustedTypesTrustedHtmlOrString) -> !:
    # 1. Let compliantString be the result of invoking the Get Trusted Type compliant string algorithm with
    #      TrustedHTML, this's relevant global object, the given value, "HTMLIFrameElement srcdoc", and "script".
    let compliant_string = try trusted_types_get_trusted_type_compliant_string(TrustedTypesTrustedTypeName.trusted_html, html_relevant_global_object((JsObject*)this), html_htmli_frame_element_trusted_type_input(value), TrustedTypesInjectionSink.htmli_frame_element_srcdoc, ak.fly_string_to_string_const(&trusted_types_script))

    # 2. Set an attribute value given this, srcdoc's local name, and compliantString.
    dom_element_set_attribute_value(this.dom_element(), html_attribute_names_srcdoc, ak.utf16_string_base_to_utf8_but_should_be_ported_to_utf16(&compliant_string.utf16_string_base))

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

## Ported from HTMLIFrameElement.h:20 Web::HTML::HTMLIFrameElement::is_lazy_loading (override; LAZY_LOADING_ELEMENT).
pub func html_htmli_frame_element_is_lazy_loading_impl(base: DomNode*) -> bool:
    return true

## Ported from HTMLIFrameElement.h:20 Web::HTML::HTMLIFrameElement::take_lazy_load_resumption_steps (override; LAZY_LOADING_ELEMENT).
pub func html_htmli_frame_element_take_lazy_load_resumption_steps_impl(base: DomElement*) -> gc.Function0[unit]*?:
    return html_lazy_loading_element_take_lazy_load_resumption_steps_internal((HtmlHtmliFrameElement*)base)

## Ported from HTMLIFrameElement.h:30 Web::HTML::HTMLIFrameElement::is_focusable (override).
pub func html_htmli_frame_element_is_focusable_impl(base: DomEventTarget*) -> bool:
    return true

## Ported from HTMLIFrameElement.h:34 Web::HTML::HTMLIFrameElement::pending_resource_start_time.
pub func html_htmli_frame_element_pending_resource_start_time(this: HtmlHtmliFrameElement*) -> f64?:
    return this.m_pending_resource_start_time

## Ported from HTMLIFrameElement.h:35 Web::HTML::HTMLIFrameElement::set_pending_resource_start_time.
pub func html_htmli_frame_element_set_pending_resource_start_time(this: HtmlHtmliFrameElement*, time: f64?):
    this.m_pending_resource_start_time = time

## Ported from HTMLIFrameElement.h:39 Web::HTML::HTMLIFrameElement::iframe_sandboxing_flag_set.
pub func html_htmli_frame_element_iframe_sandboxing_flag_set(this: HtmlHtmliFrameElement*) -> HtmlSandboxingFlagSet:
    return this.m_iframe_sandboxing_flag_set

## Ported from HTMLIFrameElement.h:46 Web::HTML::HTMLIFrameElement::set_iframe_fullscreen_flag.
pub func html_htmli_frame_element_set_iframe_fullscreen_flag(this: HtmlHtmliFrameElement*, iframe_fullscreen_flag: bool):
    this.m_iframe_fullscreen_flag = iframe_fullscreen_flag

## Ported from HTMLIFrameElement.h:47 Web::HTML::HTMLIFrameElement::iframe_fullscreen_flag.
pub func html_htmli_frame_element_iframe_fullscreen_flag(this: HtmlHtmliFrameElement*) -> bool:
    return this.m_iframe_fullscreen_flag

## Ported from HTMLIFrameElement.h:55 Web::HTML::HTMLIFrameElement::is_html_iframe_element (override).
pub func html_htmli_frame_element_is_html_iframe_element_impl(base: DomNode*) -> bool:
    return true

## Ported from HTMLIFrameElement.h:66 Web::HTML::HTMLIFrameElement::supports_dimension_attributes (override).
# https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element:dimension-attributes
pub func html_htmli_frame_element_supports_dimension_attributes_impl(base: DomElement*) -> bool:
    return true