dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / 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