Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / webview / page_client.lucb

#==============================================================================================
#
#   page_client - WebContent's PageClient, in process
#
#   DESCRIPTION:
#       Port of the parts of Services/WebContent/PageClient.cpp (lines 67-800) that a page
#       without script, devtools or WebDriver reaches, and of PageHost.cpp (lines 18-23, the
#       client and its fresh top-level traversable). Ladybird's PageClient forwards what the
#       page reports to the UI process (`client().async_did_*`), where WebContentClient hands it
#       to the ViewImplementation; here each report is a direct call on the view (view.lucb).
#       The palette is WebContent's (setup_palette: a zeroed theme with magenta and cyan window
#       colors). The input event queue is ConnectionFromClient's (one client per view here).
#       The frame timer is WebContent's: request_frame queues "update the rendering" at most
#       maximum_frames_per_second times a second.
#
#       Copyright (c) 2020-2023, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2021-2022, Linus Groh <linusg@serenityos.org>
#       Copyright (c) 2023, Andrew Kaster <akaster@serenityos.org>
#       Copyright (c) 2024, Sam Atkins <sam@ladybird.org>
#       Copyright (c) 2026 the luce-browser authors.
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: The client ==============================================================================

## WebContent::PageClient: a cell, as the C++ one is (its class id is PageClient's).
pub struct WebViewPageClient: gc.IsCell:
    var page_client: web.PageClient
    var m_page: web.Page*?
    var m_id: u64
    var m_view: WebView*?
    var m_palette_impl: gfx.PaletteImpl*?
    var m_screen_rect: gfx.DevicePixelRect
    var m_viewport_size: gfx.IntSize
    var m_device_pixel_ratio: f64
    var m_zoom_level: f64
    var m_maximum_frames_per_second: f64
    var m_preferred_color_scheme: web.CssPreferredColorScheme
    var m_frame_timer: web.CoreTimer*?
    var m_last_frame_dispatch_time: f64?
    ## ConnectionFromClient's m_input_event_queue.
    var m_input_event_queue: ak.Queue[web.QueuedInputEvent]
    ## The ids of the page's network requests in flight (page_did_start_network_request, which
    ## WebContent forwards to the UI's devtools), which closing the page ends.
    var m_network_requests: ak.Vector[u64]

    func cell() -> gc.Cell*: return (gc.Cell*)&self

## The client of a PageClient this file made.
func webview_page_client_of(base: web.PageClient*) -> WebViewPageClient*:
    return (WebViewPageClient*)base

## The view of a client, none once the view is destroyed (WebContentClient's view_for_page_id: a
## report for a view that is gone is dropped).
func webview_client_view(base: web.PageClient*) -> WebView*?:
    return webview_page_client_of(base).m_view

## Ported from Services/WebContent/PageClient.cpp:86 WebContent::PageClient::visit_edges.
func webview_page_client_visit_edges(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (WebViewPageClient*)base
    gc.cell_visit_edges_impl(base, visitor)
    gc.cell_visitor_visit_t(visitor, this.m_page)

func webview_page_client_id(this: web.PageClient*) -> u64:
    return webview_page_client_of(this).m_id

func webview_page_client_page(this: web.PageClient*) -> web.Page*:
    return webview_page_client_of(this).m_page else trap("webview: the PageClient has no page")

## In process the connection to the UI is the view, open while the client exists.
func webview_page_client_is_connection_open(this: web.PageClient*) -> bool:
    return true

## WebView::is_url_suitable_for_same_process_navigation: there is one process.
func webview_page_client_is_url_suitable_for_same_process_navigation(this: web.PageClient*, current_url: web_url.Url, target_url: web_url.Url) -> bool:
    return true

## Ported from Services/WebContent/PageClient.cpp:127 WebContent::PageClient::palette.
func webview_page_client_palette(this: web.PageClient*) -> gfx.Palette:
    var palette: gfx.Palette = ---
    gfx.palette_construct(&palette, webview_page_client_of(this).m_palette_impl else trap("webview: no palette"))
    return palette

func webview_page_client_screen_rect(this: web.PageClient*) -> gfx.DevicePixelRect:
    return webview_page_client_of(this).m_screen_rect

func webview_page_client_zoom_level(this: web.PageClient*) -> f64:
    return webview_page_client_of(this).m_zoom_level

func webview_page_client_device_pixel_ratio(this: web.PageClient*) -> f64:
    return webview_page_client_of(this).m_device_pixel_ratio

## Ported from Services/WebContent/PageClient.h:62 WebContent::PageClient::device_pixels_per_css_pixel.
func webview_page_client_device_pixels_per_css_pixel(this: web.PageClient*) -> f64:
    let client = webview_page_client_of(this)
    return client.m_device_pixel_ratio * client.m_zoom_level

func webview_page_client_preferred_color_scheme(this: web.PageClient*) -> web.CssPreferredColorScheme:
    return webview_page_client_of(this).m_preferred_color_scheme

func webview_page_client_preferred_contrast(this: web.PageClient*) -> web.CssPreferredContrast:
    return web.CssPreferredContrast.auto

func webview_page_client_preferred_motion(this: web.PageClient*) -> web.CssPreferredMotion:
    return web.CssPreferredMotion.auto

func webview_page_client_screen_count(this: web.PageClient*) -> usize:
    return 1

## Ported from Services/WebContent/PageClient.cpp:196 WebContent::PageClient::input_event_queue.
func webview_page_client_input_event_queue(this: web.PageClient*) -> ak.Queue[web.QueuedInputEvent]*:
    return &webview_page_client_of(this).m_input_event_queue

## Ported from Services/WebContent/PageClient.cpp:201 WebContent::PageClient::report_finished_handling_input_event.
func webview_page_client_report_finished_handling_input_event(this: web.PageClient*, page_id: u64, event_was_handled: web.EventResult):
    let view = webview_client_view(this) else return
    webview_did_finish_handling_input_event(view, event_was_handled)

## The lambda of PageClient::PageClient's frame timer: the rendering is updated on the next turn.
func webview_page_client_frame_timer_fired(context: void*?):
    let client = (WebViewPageClient*)(context else trap("webview: a frame timer without its client"))
    client.m_last_frame_dispatch_time = web.high_resolution_time_unsafe_shared_current_time()
    web.html_event_loop_queue_task_to_update_the_rendering(web.html_main_thread_event_loop())

## Ported from Services/WebContent/PageClient.cpp:225 WebContent::PageClient::request_frame.
## A hidden page asks for none: in Ladybird its WebContent process would queue the update of the
## rendering for its own navigables only, none of which has a rendering opportunity while hidden,
## so the frame would do nothing; here the event loop is every page's, and the frame would update
## the rendering of the visible ones. Showing the page asks for a frame (webview_page_client_set_system_visibility_state).
func webview_page_client_request_frame(this: web.PageClient*):
    let client = webview_page_client_of(this)
    let frame_timer = client.m_frame_timer else trap("webview: no frame timer")
    if web.core_timer_is_active(frame_timer):
        return
    let page = client.m_page else return
    if web.html_traversable_navigable_system_visibility_state(web.page_top_level_traversable(page)) == web.HtmlVisibilityState.hidden:
        return

    var delay = 0.0
    if let last_frame_dispatch_time = client.m_last_frame_dispatch_time:
        let now = web.high_resolution_time_unsafe_shared_current_time()
        let minimum_frame_interval = 1000.0 / client.m_maximum_frames_per_second
        delay = math.max(0.0, last_frame_dispatch_time + minimum_frame_interval - now)

    web.core_timer_restart_i32(frame_timer, (i32)math.ceil(delay))

# mark: What the page reports ===================================================================

## PageClient::page_did_request_cursor_change (WebContentClient::did_request_cursor_change).
func webview_page_client_page_did_request_cursor_change(this: web.PageClient*, cursor: gfx.Cursor):
    let view = webview_client_view(this) else return
    webview_did_request_cursor_change(view, cursor)

## PageClient::page_did_change_title (WebContentClient::did_change_title).
func webview_page_client_page_did_change_title(this: web.PageClient*, title: ak.Utf16String):
    let view = webview_client_view(this) else return
    webview_did_change_title(view, title)

## PageClient::page_did_change_url (WebContentClient::did_change_url).
func webview_page_client_page_did_change_url(this: web.PageClient*, url: web_url.Url):
    let view = webview_client_view(this) else return
    webview_did_change_url(view, url)

## PageClient::page_did_request_refresh (WebContentClient::did_request_refresh: the view reloads).
func webview_page_client_page_did_request_refresh(this: web.PageClient*):
    let view = webview_client_view(this) else return
    webview_reload(view)

## PageClient::page_did_hover_link (WebContentClient::did_hover_link).
func webview_page_client_page_did_hover_link(this: web.PageClient*, url: web_url.Url):
    let view = webview_client_view(this) else return
    webview_did_hover_link(view, url)

## PageClient::page_did_unhover_link (WebContentClient::did_unhover_link).
func webview_page_client_page_did_unhover_link(this: web.PageClient*):
    let view = webview_client_view(this) else return
    webview_did_unhover_link(view)

## PageClient::page_did_start_loading (WebContentClient::did_start_loading).
func webview_page_client_page_did_start_loading(this: web.PageClient*, url: web_url.Url, is_redirect: bool):
    let view = webview_client_view(this) else return
    webview_did_start_loading(view, url, is_redirect)

## PageClient::page_did_finish_loading (WebContentClient::did_finish_loading).
func webview_page_client_page_did_finish_loading(this: web.PageClient*, url: web_url.Url):
    let view = webview_client_view(this) else return
    webview_did_finish_loading(view, url)

## PageClient::page_did_update_navigation_buttons_state (WebContentClient::did_update_navigation_buttons_state).
func webview_page_client_page_did_update_navigation_buttons_state(this: web.PageClient*, back_enabled: bool, forward_enabled: bool):
    let view = webview_client_view(this) else return
    webview_did_update_navigation_buttons_state(view, back_enabled, forward_enabled)

## PageClient::page_did_paint (WebContentClient::did_paint).
func webview_page_client_page_did_paint(this: web.PageClient*, content_rect: gfx.DevicePixelRect, bitmap_id: i32):
    let view = webview_client_view(this) else return
    webview_server_did_paint(view, bitmap_id, gfx.device_pixel_rect_size(&content_rect))

## PageClient::page_did_take_screenshot (WebContentClient::did_take_screenshot).
func webview_page_client_page_did_take_screenshot(this: web.PageClient*, screenshot: gfx.ShareableBitmap):
    let view = webview_client_view(this) else return
    webview_did_receive_screenshot(view, screenshot)

## PageClient::page_did_start_network_request: the request is the page's until it finishes.
func webview_page_client_page_did_start_network_request(this: web.PageClient*, request_id: u64, url: web_url.Url, method: ak.ByteString, request_headers: ak.Vector[web.HttpHeader],
                                                        request_body: const u8[], initiator_type: ak.String?):
    ak.vector_append_t(&webview_page_client_of(this).m_network_requests, request_id)

## PageClient::page_did_finish_network_request.
func webview_page_client_page_did_finish_network_request(this: web.PageClient*, request_id: u64, body_size: u64, timing_info: web.RequestsRequestTimingInfo, network_error: web.RequestsNetworkError?):
    let client = webview_page_client_of(this)
    if let index = ak.vector_find_first_index(&client.m_network_requests, request_id):
        _ = ak.vector_take(&client.m_network_requests, index)

## PageClient::request_file: WebContent asks the UI process to open the file
## (ViewImplementation's on_request_file); in process the engine opens it on the next turn.
func webview_page_client_request_file(this: web.PageClient*, request: web.FileRequest):
    web.in_process_request_file(request)

## The painter WebContent picks without a GPU backend: the CPU player.
func webview_page_client_display_list_player_type(this: web.PageClient*) -> web.DisplayListPlayerType:
    return web.DisplayListPlayerType.skia_cpu

func webview_page_client_is_headless(this: web.PageClient*) -> bool:
    return false

func webview_page_client_is_svg_page_client(this: web.PageClient*) -> bool:
    return false

## The client's vtable: PageClient's, with WebContent's overrides of what the page reaches.
let webview_page_client_vtable: web.PageClientVTable = web.PageClientVTable(
    cell_vtable = web.JsCellVTable(cell_vtable = gc.CellVTable(class_info = &webview_page_client_class, visit_edges = webview_page_client_visit_edges)),
    id = webview_page_client_id,
    page = webview_page_client_page,
    page_const = webview_page_client_page,
    is_connection_open = webview_page_client_is_connection_open,
    is_url_suitable_for_same_process_navigation = webview_page_client_is_url_suitable_for_same_process_navigation,
    palette = webview_page_client_palette,
    screen_rect = webview_page_client_screen_rect,
    zoom_level = webview_page_client_zoom_level,
    device_pixel_ratio = webview_page_client_device_pixel_ratio,
    device_pixels_per_css_pixel = webview_page_client_device_pixels_per_css_pixel,
    preferred_color_scheme = webview_page_client_preferred_color_scheme,
    preferred_contrast = webview_page_client_preferred_contrast,
    preferred_motion = webview_page_client_preferred_motion,
    screen_count = webview_page_client_screen_count,
    input_event_queue = webview_page_client_input_event_queue,
    report_finished_handling_input_event = webview_page_client_report_finished_handling_input_event,
    request_frame = webview_page_client_request_frame,
    page_did_change_title = webview_page_client_page_did_change_title,
    page_did_change_url = webview_page_client_page_did_change_url,
    page_did_request_refresh = webview_page_client_page_did_request_refresh,
    page_did_start_loading = webview_page_client_page_did_start_loading,
    page_did_finish_loading = webview_page_client_page_did_finish_loading,
    page_did_request_cursor_change = webview_page_client_page_did_request_cursor_change,
    page_did_hover_link = webview_page_client_page_did_hover_link,
    page_did_unhover_link = webview_page_client_page_did_unhover_link,
    page_did_update_navigation_buttons_state = webview_page_client_page_did_update_navigation_buttons_state,
    request_file = webview_page_client_request_file,
    page_did_start_network_request = webview_page_client_page_did_start_network_request,
    page_did_finish_network_request = webview_page_client_page_did_finish_network_request,
    page_did_paint = webview_page_client_page_did_paint,
    page_did_take_screenshot = webview_page_client_page_did_take_screenshot,
    display_list_player_type = webview_page_client_display_list_player_type,
    is_headless = webview_page_client_is_headless,
    is_svg_page_client = webview_page_client_is_svg_page_client,
)

## The class of the client: a PageClient (its class id; a constant expression cannot read
## web.page_client_class's ids, so webview_page_client_create checks they agree).
let webview_page_client_class: ak.ClassInfo = ak.ClassInfo(name = "WebViewPageClient", first_id = 316, last_id = 316, size = memory.size_of(WebViewPageClient),
                                                           vtable = (const void*)&webview_page_client_vtable)

# mark: Creating the client =====================================================================

## Ported from Services/WebContent/PageClient.cpp:67 WebContent::PageClient::create (with
## PageClient::PageClient: the page by Page::create, the palette, the frame timer), for `view`.
## Runs with the VM's heap current.
pub func webview_page_client_create(vm: web.Vm*, view: WebView*, id: u64) -> WebViewPageClient*:
    assert(webview_page_client_class.first_id == web.page_client_class.first_id and webview_page_client_class.last_id == web.page_client_class.last_id,
           "the view's PageClient has PageClient's class id")
    let heap = web.vm_heap(vm)
    gc.heap_defer_gc(heap)
    let client = (WebViewPageClient*)web.web_heap_allocate_cell(heap, &webview_page_client_class)
    client.m_id = id
    client.m_view = view
    client.m_device_pixel_ratio = 1.0
    client.m_zoom_level = 1.0
    client.m_maximum_frames_per_second = 60.0
    client.m_preferred_color_scheme = web.CssPreferredColorScheme.auto
    client.m_page = web.page_create(vm, &client.page_client)
    webview_page_client_setup_palette(client)
    client.m_frame_timer = web.core_timer_create_single_shot(0, ak.Function0[unit](call = webview_page_client_frame_timer_fired, context = client))
    gc.heap_undefer_gc(heap)
    client.m_screen_rect = gfx.DevicePixelRect(m_location = gfx.IntPoint(m_x = 0, m_y = 0), m_size = gfx.IntSize(m_width = 1920, m_height = 1080))
    return client

## Ported from Services/WebContent/PageClient.cpp:110 WebContent::PageClient::setup_palette.
func webview_page_client_setup_palette(client: WebViewPageClient*):
    let buffer = gfx.core_anonymous_buffer_create_with_size(memory.size_of(gfx.SystemTheme)) else trap("VERIFY: the theme buffer")
    let theme = (gfx.SystemTheme*)(gfx.core_anonymous_buffer_data(&buffer) else trap("VERIFY: the theme buffer"))
    let magenta = gfx.color_new_named_color(gfx.ColorNamedColor.magenta)
    let cyan = gfx.color_new_named_color(gfx.ColorNamedColor.cyan)
    theme.color[(i32)gfx.ColorRole.window] = gfx.color_value(&magenta)
    theme.color[(i32)gfx.ColorRole.window_text] = gfx.color_value(&cyan)
    client.m_palette_impl = gfx.palette_impl_create_with_anonymous_buffer(buffer)

## Ported from Services/WebContent/PageClient.cpp:206 WebContent::PageClient::set_viewport: the
## top-level traversable's viewport in CSS pixels, its display list invalidated when the
## device pixel ratio changed.
pub func webview_page_client_set_viewport(client: WebViewPageClient*, size: gfx.IntSize, device_pixel_ratio: f64):
    let invalidate = web.InvalidateDisplayList.yes if client.m_device_pixel_ratio != device_pixel_ratio else web.InvalidateDisplayList.no
    client.m_viewport_size = size
    client.m_device_pixel_ratio = device_pixel_ratio
    let page = client.m_page else trap("webview: no page")
    let traversable = web.page_top_level_traversable(page)
    web.html_navigable_set_viewport_size((web.HtmlNavigable*)traversable, web.page_device_to_css_size(page, size), invalidate)

## Ported from Services/WebContent/PageClient.cpp:217 WebContent::PageClient::set_zoom_level.
pub func webview_page_client_set_zoom_level(client: WebViewPageClient*, zoom_level: f64):
    client.m_zoom_level = zoom_level
    let page = client.m_page else trap("webview: no page")
    let traversable = web.page_top_level_traversable(page)
    web.html_navigable_set_viewport_size((web.HtmlNavigable*)traversable, web.page_device_to_css_size(page, client.m_viewport_size), web.InvalidateDisplayList.yes)

## Ported from Services/WebContent/ConnectionFromClient.cpp:1266
## WebContent::ConnectionFromClient::set_system_visibility_state: the top-level traversable's
## system visibility state, which queues the update of its documents' visibility state (they fire
## visibilitychange) and decides whether it has a rendering opportunity
## (Navigable::has_a_rendering_opportunity). A page made visible asks for a frame, so what changed
## while it was hidden is painted at once: its frame requests were dropped meanwhile.
pub func webview_page_client_set_system_visibility_state(client: WebViewPageClient*, visibility_state: web.HtmlVisibilityState):
    let page = client.m_page else trap("webview: no page")
    web.html_traversable_navigable_set_system_visibility_state(web.page_top_level_traversable(page), visibility_state)
    if visibility_state == web.HtmlVisibilityState.visible:
        webview_page_client_request_frame(&client.page_client)

## Ported from Services/WebContent/PageClient.cpp:191 WebContent::PageClient::ready_to_paint.
pub func webview_page_client_ready_to_paint(client: WebViewPageClient*):
    let page = client.m_page else trap("webview: no page")
    web.html_navigable_ready_to_paint((web.HtmlNavigable*)web.page_top_level_traversable(page))

# mark: PageHost ================================================================================

## The lambda of create_a_fresh_top_level_traversable that finishes the initial about:blank
## document.
func webview_initial_document_the_end(context: void*?):
    let traversable = (web.HtmlTraversableNavigable*)(context else trap("webview: no traversable"))
    # A view destroyed before this turn took its page's documents with it (webview_page_host_remove_page).
    if web.html_navigable_has_been_destroyed((web.HtmlNavigable*)traversable):
        return
    let document = web.html_navigable_active_document((web.HtmlNavigable*)traversable) else trap("webview: no initial document")
    web.html_parser_the_end(document)

## Ported from Services/WebContent/PageHost.cpp:18 WebContent::PageHost::PageHost: the client's
## page gets TraversableNavigable::create_a_fresh_top_level_traversable(page, about:blank), without
## that function's AD-HOC emulated geolocation position (Geolocation is phase 4; web_test's
## worker does the same): a new top-level traversable set as the page's, its initial about:blank
## document marked as finished parsing on the event loop.
pub func webview_page_host_create_top_level_traversable(page: web.Page*) -> web.HtmlTraversableNavigable*:
    let traversable = web.html_traversable_navigable_create_a_new_top_level_traversable(page, none, ak.string_from_str(""))
    web.page_set_top_level_traversable(page, traversable)
    let heap = gc.cell_heap((gc.Cell*)traversable)
    web.platform_event_loop_plugin_deferred_invoke(web.platform_event_loop_plugin_the(),
                                                   gc.create_function0(heap, ak.Function0[unit](call = webview_initial_document_the_end, context = traversable)))
    return traversable

# mark: Removing the page =======================================================================

## The filter of the page's documents: those whose page is `context`.
func webview_is_document_of_page(context: void*?, document: web.DomDocument*) -> bool:
    let page = (web.Page*)(context else trap("webview: no page"))
    return web.dom_document_page(document) == page

## The filter of the page's tasks: those whose document's page is `context`.
func webview_is_task_of_page(context: void*?, task: web.HtmlTask*) -> bool:
    let page = (web.Page*)(context else trap("webview: no page"))
    let document = web.html_task_document(task) else return false
    return web.dom_document_page(document) == page

## Ends the page's network requests still in flight (RequestServer, when a WebContent process
## exits, ends every request of that client): each is stopped (Requests::Request::stop: nothing more
## is delivered, its connection closes or leaves the pool's queue) and leaves the process's
## ResourceLoader as finish_network_request has a finished one leave it.
func webview_stop_network_requests(client: WebViewPageClient*):
    let loader = web.s_resource_loader else return
    while not ak.vector_is_empty(&client.m_network_requests):
        let request_id = ak.vector_take_last(&client.m_network_requests)
        var removed: gc.Root[web.RequestsRequest]? = none
        with memory.heap:
            removed = ak.hash_map_take_k(&loader.m_active_requests, request_id)
        var root = removed else continue
        if let request = gc.root_ptr(&root):
            _ = web.requests_request_stop(request)
        gc.root_release(&root)
        loader.m_pending_loads -= 1
        if ak.function0_is_set(&loader.on_load_counter_change):
            ak.function0_call(&loader.on_load_counter_change)

## Stops the timers a document holds itself (its cursor blink and its refresh); Ladybird's are
## stopped by the Document's destructor (~EventReceiver).
func webview_stop_document_timers(document: web.DomDocument*):
    if let cursor_blink_timer = document.m_cursor_blink_timer:
        web.core_timer_stop(cursor_blink_timer)
    if let refresh_timer = document.m_active_refresh_timer:
        web.core_timer_stop(refresh_timer)

## Closes the client's page as a tab of Ladybird closes: the UI drops its view, the WebContent
## process hosting the page exits, and RequestServer ends that client's requests. In process,
## nothing of the page may outlive the view, or wait on a turn of the shared event loop:
##   1. the page's network requests stop (RequestServer's connection closing);
##   2. the top-level traversable is destroyed (TraversableNavigable::destroy_top_level_traversable,
##      as close_top_level_traversable's afterAllUnloads does, without the unload: the process
##      would exit). It queues the destruction of the documents as tasks that can no longer run
##      once the traversable left all navigables (the documents have no navigable), so the active
##      documents are destroyed at once, deepest first (Document::destroy: aborted, became
##      inactive, their tasks removed, marked destroyed);
##   3. the tasks still queued for any document of the page (the documents left behind by its
##      navigations) are removed, and the timers its documents and navigables hold and the
##      client's frame timer stop.
## The client keeps its page: what the client is rooted by (the view) goes, and the collector
## takes the rest later (PageHost::remove_page). Runs with the VM's heap current.
pub func webview_page_host_remove_page(client: WebViewPageClient*):
    if let frame_timer = client.m_frame_timer:
        web.core_timer_stop(frame_timer)
    let page = client.m_page else return
    let traversable = web.page_top_level_traversable(page)
    let event_loop = web.html_main_thread_event_loop()
    var documents = web.html_event_loop_documents_in_this_event_loop_matching(event_loop, ak.Function1[web.DomDocument*, bool](call = webview_is_document_of_page, context = page))

    # 1. The page's network requests stop.
    webview_stop_network_requests(client)

    # 2. The top-level traversable is destroyed, then the documents it would destroy on later turns.
    if not web.html_navigable_has_been_destroyed((web.HtmlNavigable*)traversable):
        var active_documents: ak.Vector[web.DomDocument*]
        if let top = web.html_navigable_active_document((web.HtmlNavigable*)traversable):
            var navigables = web.dom_document_inclusive_descendant_navigables(top)
            for entry in ak.vector_span(&navigables):
                let navigable = entry else trap("webview: a null navigable")
                if let document = web.html_navigable_active_document(navigable):
                    ak.vector_append_t(&active_documents, document)
                # The navigable's backing store shrink timer (~BackingStoreManager stops Ladybird's).
                if let shrink_timer = navigable.m_backing_store_manager.m_backing_store_shrink_timer:
                    web.core_timer_stop(shrink_timer)
        web.html_traversable_navigable_destroy_top_level_traversable(traversable)
        var index = ak.vector_size(&active_documents)
        while index > 0:
            index -= 1
            let document = *ak.vector_at(&active_documents, index)
            if not web.dom_document_has_been_destroyed(document):
                web.dom_document_destroy(document)

    # 3. What is left of the page's documents on the event loop.
    web.html_task_queue_remove_tasks_matching(web.html_event_loop_task_queue(event_loop), ak.Function1[web.HtmlTask*, bool](call = webview_is_task_of_page, context = page))
    for document in ak.vector_span(&documents):
        webview_stop_document_timers(document else trap("webview: a null document"))