Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / svg / svg_decoded_image_data.lucb

#==============================================================================================
#
#   svg_decoded_image_data - SVG::SVGDecodedImageData: an SVG document used as an image
#
#   DESCRIPTION:
#       Port of LibWeb/SVG/SVGDecodedImageData.cpp (lines 1-238) with the inline members of
#       SVGDecodedImageData.h: the image's own Page (scripting disabled) on an SVGPageClient
#       that defers to the host page's client, its top-level traversable, an XML Document made
#       from navigation params of a response for the image's URL, made the traversable's active
#       document; the natural size from the root <svg>'s width, height and viewBox; and the
#       document rendered at a size, into a display list (painting) or a cached surface and
#       bitmap.
#
#       Parsing the bytes goes through XML::Parser (luce-xml, external/lib_xml/parser) and
#       XMLDocumentBuilder (`xml_parse_with_document_builder`, region p2x); the fetching that
#       delivers an image's bytes (HTML::SharedResourceRequest) is phase 2's fetch regions.
#       DisplayListPlayerSkia is the CPU player (DESIGN.md §7.3).
#
#==============================================================================================

# mark: Creation =================================================================================

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.cpp:32 Web::SVG::SVGDecodedImageData::create.
pub func svg_decoded_image_data_create(realm: Realm*, host_page: Page*, url: web_url.Url, data: const u8[]) -> SvgDecodedImageData*!:
    let svg_page_client = svg_decoded_image_data_svg_page_client_create(bind_main_thread_vm(), host_page)
    let page = page_create(bind_main_thread_vm(), svg_page_client.page_client())
    page_set_is_scripting_enabled(page, false)
    svg_page_client.m_svg_page = page
    page_set_top_level_traversable(page, html_traversable_navigable_create_a_new_top_level_traversable(page, none, ak.String()))
    let navigable = (HtmlNavigable*)page_top_level_traversable(page)
    let navigable_heap = gc.cell_heap(navigable.cell())
    let response = fetch_infrastructure_response_create(js_cell_vm(navigable.js_cell()))
    ak.vector_append_t(fetch_response_url_list(response), url)
    let origin = web_url.origin_create_opaque()
    let navigation_params = heap_allocate_html_navigation_params(navigable_heap, none,
                                                                 navigable,
                                                                 none,
                                                                 response,
                                                                 none,
                                                                 none,
                                                                 HtmlOpenerPolicyEnforcementResult(url = url, origin = origin, opener_policy = HtmlOpenerPolicy()),
                                                                 none,
                                                                 origin,
                                                                 heap_allocate_html_policy_container(realm_heap(realm)),
                                                                 (HtmlSandboxingFlagSet)0,
                                                                 HtmlOpenerPolicy(),
                                                                 none,
                                                                 HtmlUserNavigationInvolvement.none_)

    # FIXME: Use Navigable::navigate() instead of manually replacing the navigable's document.
    let document = dom_document_create_and_initialize(DocumentDomDocumentType.xml, ak.string_from_str("image/svg+xml"), navigation_params) else trap("MUST: Document::create_and_initialize")
    html_navigable_set_ongoing_navigation(navigable, EmptyOrHtmlNavigableTraversalOrString.empty)
    dom_document_destroy(html_navigable_active_document(navigable) else trap("VERIFY: active_document()"))
    html_navigable_set_active_document(navigable, document)
    let window = as_html_window((gc.Cell*)html_relevant_global_object((JsObject*)document))
    let browsing_context = dom_document_browsing_context(document) else trap("VERIFY: browsing_context()")
    html_window_proxy_set_window(html_browsing_context_window_proxy(browsing_context) else trap("VERIFY: window_proxy()"), window)

    # XML::Parser parser(data, { .resolve_named_html_entity = resolve_named_html_entity });
    # XMLDocumentBuilder builder { document, XMLScriptingSupport::Disabled };
    # auto result = parser.parse_with_listener(builder);
    # (The seam takes the source as a String: the bytes as UTF-8, any invalid sequence replaced.)
    let source = ak.string_from_utf8_with_replacement_character(ak.string_view_from_bytes(data), ak.StringWithBomHandling.no)
    let result = xml_parse_with_document_builder(document, source, XmlParserOptions(resolve_named_html_entity = resolve_named_html_entity), XmlScriptingSupport.disabled)
    if let parse_error = result.parse_error:
        ak.dbgln(f"SVGDecodedImageData: Failed to parse SVG: {ak.string_view_text(ak.string_bytes_as_string_view(&parse_error))}")

    # Mark the document as completely loaded so that <use> elements
    # (which defer cloning until the document is complete) resolve
    # forward references to elements parsed after them.
    dom_document_completely_finish_loading(document)

    let svg_root = tree_node_first_child_of_type(document.dom_node(), &svg_svgsvg_element_class)
    if svg_root == none:
        ak.dbgln("SVGDecodedImageData: Invalid SVG input (no SVGSVGElement found)")
        error(ak.ak_error, "SVGDecodedImageData: Invalid SVG input")
    let root_element = as_svg_svgsvg_element(svg_root else trap("VERIFY: svg_root"))
    return realm_create_svg_decoded_image_data(realm, page, svg_page_client, document, root_element)

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.cpp:85 Web::SVG::SVGDecodedImageData::SVGDecodedImageData.
pub func svg_decoded_image_data_construct(this: SvgDecodedImageData*, page: Page*, page_client_: SvgDecodedImageDataSvgPageClient*, document: DomDocument*, root_element: SvgSvgsvgElement*):
    html_decoded_image_data_construct(this.html_decoded_image_data())
    this.m_page = page
    this.m_page_client = page_client_
    this.m_document = document
    this.m_root_element = root_element

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.cpp:95 Web::SVG::SVGDecodedImageData::visit_edges (override).
pub func svg_decoded_image_data_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (SvgDecodedImageData*)base
    gc.cell_visit_edges_impl(base, visitor)
    gc.cell_visitor_visit_t(visitor, this.m_page)
    gc.cell_visitor_visit_t(visitor, this.m_document)
    gc.cell_visitor_visit_t(visitor, this.m_page_client)
    gc.cell_visitor_visit_t(visitor, this.m_root_element)

# mark: Rendering ================================================================================

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.cpp:104 Web::SVG::SVGDecodedImageData::record_display_list.
func svg_decoded_image_data_record_display_list(this: SvgDecodedImageData*, size: gfx.IntSize) -> display_list.DisplayList*?:
    let navigable = dom_document_navigable(this.m_document) else trap("VERIFY: navigable()")
    html_navigable_set_viewport_size(navigable, gfx.int_size_to_type_css_pixels(&size))
    dom_document_update_layout(this.m_document, DomUpdateLayoutReason.svg_decoded_image_data_render)
    return dom_document_record_display_list(this.m_document, HtmlPaintConfig())

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.cpp:111 Web::SVG::SVGDecodedImageData::render_to_surface.
func svg_decoded_image_data_render_to_surface(this: SvgDecodedImageData*, size: gfx.IntSize) -> gfx.PaintingSurface*?:
    assert(dom_document_navigable(this.m_document) != none)

    if gfx.int_size_is_empty(&size):
        return none

    if let cached = ak.hash_map_get_k(&this.m_cached_rendered_surfaces, size):
        return *cached

    # Prevent the cache from growing too big.
    # FIXME: Evict least used entries.
    if ak.hash_map_size(&this.m_cached_rendered_surfaces) > 10:
        ak.hash_map_remove_opaque(&this.m_cached_rendered_surfaces, ak.hash_map_begin(&this.m_cached_rendered_surfaces))

    let surface = gfx.painting_surface_create_with_size(size, gfx.BitmapFormat.bgra8888, gfx.AlphaType.premultiplied)
    let recorded_display_list = svg_decoded_image_data_record_display_list(this, size) else return none

    match page_client_display_list_player_type(this.m_page_client.page_client()):
        .skia_gpu_if_available, .skia_cpu:
            # NB: DisplayListPlayerSkia is replaced by the CPU player over the Luce rasterizer (DESIGN.md §7.3).
            let display_list_player = display_list.display_list_player_cpu_create()
            let scroll_state_snapshot = display_list.ScrollStateSnapshot(m_device_offsets = ak.Vector[gfx.FloatPoint]())
            display_list.display_list_player_execute((display_list.DisplayListPlayer*)display_list_player, recorded_display_list, &scroll_state_snapshot, surface)
        _:
            trap("VERIFY_NOT_REACHED")

    _ = ak.hash_map_set(&this.m_cached_rendered_surfaces, size, surface)
    return surface

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.cpp:146 Web::SVG::SVGDecodedImageData::bitmap (override).
pub func svg_decoded_image_data_bitmap_impl(base: HtmlDecodedImageData*, frame_index: usize, size: gfx.IntSize) -> gfx.ImmutableBitmap*?:
    let this = (SvgDecodedImageData*)base
    if gfx.int_size_is_empty(&size):
        return none

    if let cached = ak.hash_map_get_k(&this.m_cached_rendered_bitmaps, size):
        return *cached

    # Prevent the cache from growing too big.
    # FIXME: Evict least used entries.
    if ak.hash_map_size(&this.m_cached_rendered_bitmaps) > 10:
        ak.hash_map_remove_opaque(&this.m_cached_rendered_bitmaps, ak.hash_map_begin(&this.m_cached_rendered_bitmaps))

    let surface = svg_decoded_image_data_render_to_surface(this, size) else trap("VERIFY: render_to_surface()")
    let immutable_bitmap = gfx.immutable_bitmap_create_snapshot_from_painting_surface(surface)
    _ = ak.hash_map_set(&this.m_cached_rendered_bitmaps, size, immutable_bitmap)
    return immutable_bitmap

# mark: The natural size =========================================================================

## The `width` or `height` of the root element's style as an absolute length in CSS pixels, if it is one.
func svg_decoded_image_data_absolute_size_value(this: SvgDecodedImageData*, property_id: css_data.PropertyId) -> gfx.CssPixels?:
    # https://www.w3.org/TR/SVG2/coords.html#SizingSVGInCSS
    dom_document_update_style(this.m_document)
    let root_element_style = dom_element_computed_properties(this.m_root_element.dom_element()) else trap("VERIFY: root_element_style")
    let size_value = css_computed_properties_size_value(root_element_style, property_id)
    if css_size_is_length(&size_value):
        let length = css_size_length(&size_value)
        if css_length_is_absolute(&length):
            return css_length_absolute_length_to_px(&length)
    return none

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.cpp:164 Web::SVG::SVGDecodedImageData::intrinsic_width (override).
pub func svg_decoded_image_data_intrinsic_width_impl(base: HtmlDecodedImageData*) -> gfx.CssPixels?:
    let this = (SvgDecodedImageData*)base
    # https://www.w3.org/TR/SVG2/coords.html#SizingSVGInCSS
    return svg_decoded_image_data_absolute_size_value(this, css_data.PropertyId.width)

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.cpp:176 Web::SVG::SVGDecodedImageData::intrinsic_height (override).
pub func svg_decoded_image_data_intrinsic_height_impl(base: HtmlDecodedImageData*) -> gfx.CssPixels?:
    let this = (SvgDecodedImageData*)base
    # https://www.w3.org/TR/SVG2/coords.html#SizingSVGInCSS
    return svg_decoded_image_data_absolute_size_value(this, css_data.PropertyId.height)

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.cpp:188 Web::SVG::SVGDecodedImageData::intrinsic_aspect_ratio (override).
pub func svg_decoded_image_data_intrinsic_aspect_ratio_impl(base: HtmlDecodedImageData*) -> gfx.CssPixelFraction?:
    let this = (SvgDecodedImageData*)base
    # https://www.w3.org/TR/SVG2/coords.html#SizingSVGInCSS
    let width = svg_decoded_image_data_intrinsic_width_impl(base)
    let height = svg_decoded_image_data_intrinsic_height_impl(base)
    if let width_value = width:
        if let height_value = height:
            if width_value.raw_value() > 0 and height_value.raw_value() > 0:
                return width_value.div(height_value)

    if let viewbox = svg_fit_to_view_box_view_box(&this.m_root_element.svg_fit_to_view_box):
        let viewbox_width = gfx.css_pixels_nearest_value_for_f64(viewbox.width)

        if viewbox_width.raw_value() == 0:
            return none

        let viewbox_height = gfx.css_pixels_nearest_value_for_f64(viewbox.height)
        if viewbox_height.raw_value() == 0:
            return none

        return viewbox_width.div(viewbox_height)
    return none

# mark: SVGPageClient ============================================================================

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:66 Web::SVG::SVGDecodedImageData::SVGPageClient::create.
pub func svg_decoded_image_data_svg_page_client_create(vm: Vm*, page: Page*) -> SvgDecodedImageDataSvgPageClient*:
    assert(svg_decoded_image_data_svg_page_client_class.first_id == page_client_class.first_id and svg_decoded_image_data_svg_page_client_class.last_id == page_client_class.last_id,
           "SVGPageClient has PageClient's class id")
    # vm.heap().allocate<SVGPageClient>(page)
    let heap = vm_heap(vm)
    gc.heap_defer_gc(heap)
    let this = (SvgDecodedImageDataSvgPageClient*)web_heap_allocate_cell(heap, &svg_decoded_image_data_svg_page_client_class)
    svg_decoded_image_data_svg_page_client_construct(this, page)
    gc.heap_undefer_gc(heap)
    return this

## The SVGPageClient a PageClient pointer is (the overrides' `this`).
func svg_page_client_from_page_client(base: PageClient*) -> SvgDecodedImageDataSvgPageClient*:
    return (SvgDecodedImageDataSvgPageClient*)base

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:76 Web::SVG::SVGDecodedImageData::SVGPageClient::id (override).
pub func svg_decoded_image_data_svg_page_client_id_impl(base: PageClient*) -> u64:
    trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:77 Web::SVG::SVGDecodedImageData::SVGPageClient::page (override).
pub func svg_decoded_image_data_svg_page_client_page_impl(base: PageClient*) -> Page*:
    return svg_page_client_from_page_client(base).m_svg_page else trap("VERIFY: m_svg_page")

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:78 Web::SVG::SVGDecodedImageData::SVGPageClient::page (override).
pub func svg_decoded_image_data_svg_page_client_page_const_impl(base: PageClient*) -> Page*:
    return svg_page_client_from_page_client(base).m_svg_page else trap("VERIFY: m_svg_page")

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:79 Web::SVG::SVGDecodedImageData::SVGPageClient::is_connection_open (override).
pub func svg_decoded_image_data_svg_page_client_is_connection_open_impl(base: PageClient*) -> bool:
    return false

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:80 Web::SVG::SVGDecodedImageData::SVGPageClient::palette (override).
pub func svg_decoded_image_data_svg_page_client_palette_impl(base: PageClient*) -> gfx.Palette:
    return page_client_palette(page_client(svg_page_client_from_page_client(base).m_host_page))

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:81 Web::SVG::SVGDecodedImageData::SVGPageClient::screen_rect (override).
pub func svg_decoded_image_data_svg_page_client_screen_rect_impl(base: PageClient*) -> gfx.DevicePixelRect:
    return gfx.DevicePixelRect(m_location = gfx.IntPoint(m_x = 0, m_y = 0), m_size = gfx.IntSize(m_width = 0, m_height = 0))

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:82 Web::SVG::SVGDecodedImageData::SVGPageClient::zoom_level (override).
pub func svg_decoded_image_data_svg_page_client_zoom_level_impl(base: PageClient*) -> f64:
    return 1.0

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:83 Web::SVG::SVGDecodedImageData::SVGPageClient::device_pixel_ratio (override).
pub func svg_decoded_image_data_svg_page_client_device_pixel_ratio_impl(base: PageClient*) -> f64:
    return 1.0

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:84 Web::SVG::SVGDecodedImageData::SVGPageClient::device_pixels_per_css_pixel (override).
pub func svg_decoded_image_data_svg_page_client_device_pixels_per_css_pixel_impl(base: PageClient*) -> f64:
    return 1.0

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:85 Web::SVG::SVGDecodedImageData::SVGPageClient::preferred_color_scheme (override).
pub func svg_decoded_image_data_svg_page_client_preferred_color_scheme_impl(base: PageClient*) -> CssPreferredColorScheme:
    return page_client_preferred_color_scheme(page_client(svg_page_client_from_page_client(base).m_host_page))

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:86 Web::SVG::SVGDecodedImageData::SVGPageClient::preferred_contrast (override).
pub func svg_decoded_image_data_svg_page_client_preferred_contrast_impl(base: PageClient*) -> CssPreferredContrast:
    return page_client_preferred_contrast(page_client(svg_page_client_from_page_client(base).m_host_page))

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:87 Web::SVG::SVGDecodedImageData::SVGPageClient::preferred_motion (override).
pub func svg_decoded_image_data_svg_page_client_preferred_motion_impl(base: PageClient*) -> CssPreferredMotion:
    return page_client_preferred_motion(page_client(svg_page_client_from_page_client(base).m_host_page))

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:88 Web::SVG::SVGDecodedImageData::SVGPageClient::screen_count (override).
pub func svg_decoded_image_data_svg_page_client_screen_count_impl(base: PageClient*) -> usize:
    return 1

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:89 Web::SVG::SVGDecodedImageData::SVGPageClient::request_file (override).
pub func svg_decoded_image_data_svg_page_client_request_file_impl(base: PageClient*, arg0: FileRequest):
    return

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:90 Web::SVG::SVGDecodedImageData::SVGPageClient::input_event_queue (override).
pub func svg_decoded_image_data_svg_page_client_input_event_queue_impl(base: PageClient*) -> ak.Queue[QueuedInputEvent]*:
    trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:91 Web::SVG::SVGDecodedImageData::SVGPageClient::report_finished_handling_input_event (override).
pub func svg_decoded_image_data_svg_page_client_report_finished_handling_input_event_impl(base: PageClient*, page_id: u64, event_was_handled: EventResult):
    return

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:92 Web::SVG::SVGDecodedImageData::SVGPageClient::request_frame (override).
pub func svg_decoded_image_data_svg_page_client_request_frame_impl(base: PageClient*):
    return

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:94 Web::SVG::SVGDecodedImageData::SVGPageClient::display_list_player_type (override).
pub func svg_decoded_image_data_svg_page_client_display_list_player_type_impl(base: PageClient*) -> DisplayListPlayerType:
    return page_client_display_list_player_type(page_client(svg_page_client_from_page_client(base).m_host_page))

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:95 Web::SVG::SVGDecodedImageData::SVGPageClient::is_headless (override).
pub func svg_decoded_image_data_svg_page_client_is_headless_impl(base: PageClient*) -> bool:
    return page_client_is_headless(page_client(svg_page_client_from_page_client(base).m_host_page))

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:98 Web::SVG::SVGDecodedImageData::SVGPageClient::SVGPageClient.
pub func svg_decoded_image_data_svg_page_client_construct(this: SvgDecodedImageDataSvgPageClient*, host_page: Page*):
    this.m_host_page = host_page

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:103 Web::SVG::SVGDecodedImageData::SVGPageClient::is_svg_page_client (override).
pub func svg_decoded_image_data_svg_page_client_is_svg_page_client_impl(base: PageClient*) -> bool:
    return true

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.cpp:211 Web::SVG::SVGDecodedImageData::SVGPageClient::visit_edges (override).
pub func svg_decoded_image_data_svg_page_client_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (SvgDecodedImageDataSvgPageClient*)base
    gc.cell_visit_edges_impl(base, visitor)
    gc.cell_visitor_visit_t(visitor, this.m_host_page)
    gc.cell_visitor_visit_t(visitor, this.m_svg_page)

# mark: DecodedImageData =========================================================================

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.cpp:218 Web::SVG::SVGDecodedImageData::frame_rect (override).
pub func svg_decoded_image_data_frame_rect_impl(base: HtmlDecodedImageData*, frame_index: usize) -> gfx.DevicePixelRect?:
    return none

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.cpp:223 Web::SVG::SVGDecodedImageData::surface.
## (Private in the donor and called by nothing there; public here so that an unused private function does not
## fail `check -W`.)
pub func svg_decoded_image_data_surface(this: SvgDecodedImageData*, frame_index: usize, size: gfx.IntSize) -> gfx.PaintingSurface*?:
    return svg_decoded_image_data_render_to_surface(this, size)

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.cpp:228 Web::SVG::SVGDecodedImageData::paint (override).
pub func svg_decoded_image_data_paint_impl(base: HtmlDecodedImageData*, context: DisplayListRecordingContext*, frame_index: usize, dst_rect: gfx.DevicePixelRect, clip_rect: gfx.DevicePixelRect, scaling_mode: gfx.ScalingMode):
    let this = (SvgDecodedImageData*)base
    let recorded_display_list = svg_decoded_image_data_record_display_list(this, gfx.device_pixel_rect_size(&dst_rect)) else return

    let recorder = display_list_recording_context_display_list_recorder(context)
    display_list.display_list_recorder_save(recorder)
    display_list.display_list_recorder_add_clip_rect(recorder, clip_rect)
    display_list.display_list_recorder_paint_nested_display_list(recorder, recorded_display_list, dst_rect)
    display_list.display_list_recorder_restore(recorder)

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:30 Web::SVG::SVGDecodedImageData::frame_duration (override).
# FIXME: Support SVG animations. :^)
pub func svg_decoded_image_data_frame_duration_impl(base: HtmlDecodedImageData*, arg0: usize) -> i32:
    return 0

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:31 Web::SVG::SVGDecodedImageData::frame_count (override).
pub func svg_decoded_image_data_frame_count_impl(base: HtmlDecodedImageData*) -> usize:
    return 1

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:32 Web::SVG::SVGDecodedImageData::loop_count (override).
pub func svg_decoded_image_data_loop_count_impl(base: HtmlDecodedImageData*) -> usize:
    return 0

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:33 Web::SVG::SVGDecodedImageData::is_animated (override).
pub func svg_decoded_image_data_is_animated_impl(base: HtmlDecodedImageData*) -> bool:
    return false

## Ported from Libraries/LibWeb/SVG/SVGDecodedImageData.h:35 Web::SVG::SVGDecodedImageData::svg_document.
pub func svg_decoded_image_data_svg_document(this: SvgDecodedImageData*) -> DomDocument*:
    return this.m_document