dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / 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:149 WebContent::PageClient::set_preferred_color_scheme:
## the page's `prefers-color-scheme` from now on, with its styles and media queries evaluated
## again.
pub func webview_page_client_set_preferred_color_scheme(client: WebViewPageClient*, color_scheme: web.CssPreferredColorScheme):
client.m_preferred_color_scheme = color_scheme
let page = client.m_page else return
if let document = web.html_navigable_active_document((web.HtmlNavigable*)web.page_top_level_traversable(page)):
web.dom_node_invalidate_style((web.DomNode*)document, web.DomStyleInvalidationReason.settings_change)
web.dom_document_set_needs_media_query_evaluation(document)
## 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"))