dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Libraries/LibWebView/ViewImplementation.cpp

2847 lines
125 KiB
C++
Raw Normal View History

LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 16:27:17 -03:00
/*
* Copyright (c) 2023, Linus Groh <linusg@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
LibWebView: Route wheel bypasses over Compositor IPC Send the experimental UI-process wheel bypass to WebContent over the Compositor IPC connection instead of adding a separate async scrolling transport. This keeps bypass admission on the channel that owns bitmaps and ready_to_paint acknowledgements. If the compositor rejects the wheel, LibWebView falls back to regular input delivery. If it accepts, mark the queued DOM event as having already performed its default action so dispatch preserves ordering without scrolling twice.
2026-05-11 16:45:34 -03:00
#include <AK/Debug.h>
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
#include <AK/Error.h>
Meta: Enable exit-time destructor warnings for libraries Enable -Wexit-time-destructors for all in-tree library targets and update process-lifetime library statics so they no longer register exit-time destructors. Long-lived caches, lookup tables, singleton registries, and generated constants now use NeverDestroyed or leaked references where the data is intended to live until process exit. Update LibWeb, LibLine, and the binding generators so regenerated sources follow the same rule instead of reintroducing destructed statics.
2026-06-04 05:40:32 -03:00
#include <AK/NeverDestroyed.h>
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
#include <AK/NumericLimits.h>
LibWeb+LibWebView+WebContent+UI: Add an action to cut text
2026-05-06 13:00:59 -03:00
#include <AK/ScopeGuard.h>
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
#include <AK/String.h>
Everywhere: Replace DateTime::to_string() with UnixDateTime::to_string() Replace LibCore::DateTime::to_string() with AK::UnixDateTime::to_string(). Remove unncessary #include <LibCore/DateTime.h>.
2025-06-19 16:05:42 -03:00
#include <AK/Time.h>
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
#include <LibCore/EventLoop.h>
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
#include <LibCore/StandardPaths.h>
LibIPC: Move stuff from Connection.h to .cpp and reduce #include count
2024-06-28 09:24:49 -03:00
#include <LibCore/Timer.h>
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
#include <LibGfx/ImageFormats/PNGWriter.h>
Everywhere: Replace SharedBackingStore with Gfx::SharedImage Generalize the backing store sharing abstraction into SharedImage, which represents shared GPU memory independently of Skia and can be used to share memory between different processes or different GPU contexts.
2026-04-07 13:35:26 -03:00
#include <LibGfx/SharedImageBuffer.h>
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
#include <LibURL/Parser.h>
LibWebView: Avoid white initial web view fills in dark mode Seed the page background fallback from the platform color scheme before WebContent has painted. Update the same fallback when the platform theme changes, and when the preferred color scheme is forced through the debug menu, so unpainted web view areas use the matching Canvas color.
2026-05-26 20:11:14 -03:00
#include <LibWeb/CSS/SystemColor.h>
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 18:35:17 -03:00
#include <LibWeb/Crypto/Crypto.h>
LibWebView: Add a helper to get selected text with collapsed whitespace
2023-10-23 17:52:57 -03:00
#include <LibWeb/Infra/Strings.h>
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
#include <LibWeb/WebDriver/Error.h>
LibWebView: Use the download directory facility for saving files
2024-08-28 16:32:50 -03:00
#include <LibWebView/Application.h>
LibWebView: Integrate bookmarks into the application menus and settings This adds application menus and actions to display and manage bookmarks. These menus will be used by the UIs to generate concrete widgets.
2026-03-22 12:44:54 -03:00
#include <LibWebView/BookmarkStore.h>
LibWebView+UI: Show an error page when we cannot sanitize a URL Previously, if search was disabled, entering non-URL text would just silently drop the search query (and on Qt, we would reload the current URL). We now detect that the query did not result in a navigation and load an error page instead, which directs the user to enable search.
2026-04-24 09:36:55 -03:00
#include <LibWebView/ErrorHTML.h>
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 18:35:17 -03:00
#include <LibWebView/HelperProcess.h>
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
#include <LibWebView/HistoryDebug.h>
LibWebView: Persist page metadata in history Record visits as soon as a page produces useful metadata such as a title or favicon so pages that never finish loading still become autocomplete candidates. Store favicons in the history schema from the start instead of introducing an upgrade path inside this series, and cover persisted metadata behavior in TestHistoryStore.
2026-04-11 19:33:00 -03:00
#include <LibWebView/HistoryStore.h>
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
#include <LibWebView/Menu.h>
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
#include <LibWebView/SiteIsolation.h>
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
#include <LibWebView/URL.h>
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 18:35:17 -03:00
#include <LibWebView/UserAgent.h>
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 16:27:17 -03:00
#include <LibWebView/ViewImplementation.h>
namespace WebView {
Meta: Enable exit-time destructor warnings for libraries Enable -Wexit-time-destructors for all in-tree library targets and update process-lifetime library statics so they no longer register exit-time destructors. Long-lived caches, lookup tables, singleton registries, and generated constants now use NeverDestroyed or leaked references where the data is intended to live until process exit. Update LibWeb, LibLine, and the binding generators so regenerated sources follow the same rule instead of reintroducing destructed statics.
2026-06-04 05:40:32 -03:00
static HashMap<u64, ViewImplementation*>& all_views()
{
static NeverDestroyed<HashMap<u64, ViewImplementation*>> views;
return *views;
}
LibWebView: Add simple ID tracking to WebViews For Firefox DevTools, we will need to track WebViews by a numerical ID. Here, we just increment a static 64-bit counter. We can switch to using IDAllocator if we ever have an issue with this. This patch adds such an ID to the views and a couple of APIs to access WebViews after creation.
2025-02-15 10:06:36 -03:00
static u64 s_view_count = 1; // This has to start at 1 for Firefox DevTools.
void ViewImplementation::for_each_view(Function<IterationDecision(ViewImplementation&)> callback)
{
Meta: Enable exit-time destructor warnings for libraries Enable -Wexit-time-destructors for all in-tree library targets and update process-lifetime library statics so they no longer register exit-time destructors. Long-lived caches, lookup tables, singleton registries, and generated constants now use NeverDestroyed or leaked references where the data is intended to live until process exit. Update LibWeb, LibLine, and the binding generators so regenerated sources follow the same rule instead of reintroducing destructed statics.
2026-06-04 05:40:32 -03:00
for (auto& view : all_views()) {
LibWebView: Add simple ID tracking to WebViews For Firefox DevTools, we will need to track WebViews by a numerical ID. Here, we just increment a static 64-bit counter. We can switch to using IDAllocator if we ever have an issue with this. This patch adds such an ID to the views and a couple of APIs to access WebViews after creation.
2025-02-15 10:06:36 -03:00
if (callback(*view.value) == IterationDecision::Break)
break;
}
}
Optional<ViewImplementation&> ViewImplementation::find_view_by_id(u64 id)
{
Meta: Enable exit-time destructor warnings for libraries Enable -Wexit-time-destructors for all in-tree library targets and update process-lifetime library statics so they no longer register exit-time destructors. Long-lived caches, lookup tables, singleton registries, and generated constants now use NeverDestroyed or leaked references where the data is intended to live until process exit. Update LibWeb, LibLine, and the binding generators so regenerated sources follow the same rule instead of reintroducing destructed statics.
2026-06-04 05:40:32 -03:00
if (auto view = all_views().get(id); view.has_value())
LibWebView: Add simple ID tracking to WebViews For Firefox DevTools, we will need to track WebViews by a numerical ID. Here, we just increment a static 64-bit counter. We can switch to using IDAllocator if we ever have an issue with this. This patch adds such an ID to the views and a couple of APIs to access WebViews after creation.
2025-02-15 10:06:36 -03:00
return *view.value();
return {};
}
Ladybird+LibWebView+Browser: Remove ability to run with AST interpreter
2023-08-07 11:44:20 -03:00
ViewImplementation::ViewImplementation()
LibWeb+LibWebView+WebContent: Implement versioning for document cookies This patch introduces a cookie cache in the WebContent process to reduce blocking IPC calls when JS accesses document.cookie. The UI process now maintains a cookie version counter per-domain in shared memory. When JS reads document.cookie, we check whether we have a valid cached cookie by comparing the current shared version to the last used version. If they match, the cached cookie is returned without IPC. This optimization is based on Chromium's shared versioning, in which it was observed that 87% of document.cookie accesses were redundant. See: https://blog.chromium.org/2024/06/introducing-shared-memory-versioning-to.html Note that this cache only supports document.cookie, not HTTP Cookie headers. HTTP cookies are attached to requests with varying URLs and paths. The cookies that match the document URL might not match the request URL, which we wouldn't know from WebContent. So attaching the cached document cookie would be incorrect. On https://twinings.co.uk, we see approximately 600 document.cookie requests while the page loads. This patch reduces the time spent in the document.cookie getter from ~45ms to 2-3ms.
2026-02-01 15:27:19 -03:00
: m_document_cookie_version_buffer(Core::create_shared_version_buffer())
, m_view_id(s_view_count++)
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 02:59:51 -03:00
{
Meta: Enable exit-time destructor warnings for libraries Enable -Wexit-time-destructors for all in-tree library targets and update process-lifetime library statics so they no longer register exit-time destructors. Long-lived caches, lookup tables, singleton registries, and generated constants now use NeverDestroyed or leaked references where the data is intended to live until process exit. Update LibWeb, LibLine, and the binding generators so regenerated sources follow the same rule instead of reintroducing destructed statics.
2026-06-04 05:40:32 -03:00
all_views().set(m_view_id, this);
LibWebView: Add simple ID tracking to WebViews For Firefox DevTools, we will need to track WebViews by a numerical ID. Here, we just increment a static 64-bit counter. We can switch to using IDAllocator if we ever have an issue with this. This patch adds such an ID to the views and a couple of APIs to access WebViews after creation.
2025-02-15 10:06:36 -03:00
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
initialize_context_menus();
LibWebView: Don't re-create WebContent proceses when repeatedly crashing Serenity handles this in the SystemServer already, but the simplest place to put this logic is the ViewImplementation base class. This is trivial to see when running Ladybird without SERENTIY_SOURCE_DIR set, or set improperly.
2023-05-27 13:46:45 -03:00
m_repeated_crash_timer = Core::Timer::create_single_shot(1000, [this] {
// Reset the "crashing a lot" counter after 1 second in case we just
// happen to be visiting crashy websites a lot.
this->m_crash_count = 0;
LibCore: Stop obsessing about tiny OOMs in Core::Timer Work towards #20405
2024-04-16 15:34:01 -03:00
});
Ladybird+LibWebView: Migrate file APIs to LibWebView callbacks This also sets the default callback to do what every non-Serenity browser is doing, rather than copy-pasting this callback into every implementation. The callback is still available for any platform which might want to override the default behavior. For example, OOPWV now overrides this callback to use FileSystemAccessClient.
2023-08-23 07:54:22 -03:00
on_request_file = [this](auto const& path, auto request_id) {
auto file = Core::File::open(path, Core::File::OpenMode::Read);
if (file.is_error())
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_handle_file_return(page_id(), file.error().code(), {}, request_id);
Ladybird+LibWebView: Migrate file APIs to LibWebView callbacks This also sets the default callback to do what every non-Serenity browser is doing, rather than copy-pasting this callback into every implementation. The callback is still available for any platform which might want to override the default behavior. For example, OOPWV now overrides this callback to use FileSystemAccessClient.
2023-08-23 07:54:22 -03:00
else
LibIPC+Userland: Make IPC::File always own its file descriptor Add factory functions to distinguish between when the owner of the File wants to transfer ownership to the new IPC object (adopt) or to send a copy of the same fd to the IPC peer (clone). This behavior is more intuitive than the previous behavior. Previously, an IPC::File would default to a shallow clone of the file descriptor, only *actually* calling dup(2) for the fd when encoding or it into an IPC MessageBuffer. Now the dup(2) for the fd is explicit in the clone_fd factory function.
2024-04-16 16:46:30 -03:00
client().async_handle_file_return(page_id(), 0, IPC::File::adopt_file(file.release_value()), request_id);
Ladybird+LibWebView: Migrate file APIs to LibWebView callbacks This also sets the default callback to do what every non-Serenity browser is doing, rather than copy-pasting this callback into every implementation. The callback is still available for any platform which might want to override the default behavior. For example, OOPWV now overrides this callback to use FileSystemAccessClient.
2023-08-23 07:54:22 -03:00
};
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 02:59:51 -03:00
}
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
ViewImplementation::~ViewImplementation()
{
Meta: Enable exit-time destructor warnings for libraries Enable -Wexit-time-destructors for all in-tree library targets and update process-lifetime library statics so they no longer register exit-time destructors. Long-lived caches, lookup tables, singleton registries, and generated constants now use NeverDestroyed or leaked references where the data is intended to live until process exit. Update LibWeb, LibLine, and the binding generators so regenerated sources follow the same rule instead of reintroducing destructed statics.
2026-06-04 05:40:32 -03:00
all_views().remove(m_view_id);
LibWebView: Add simple ID tracking to WebViews For Firefox DevTools, we will need to track WebViews by a numerical ID. Here, we just increment a static 64-bit counter. We can switch to using IDAllocator if we ever have an issue with this. This patch adds such an ID to the views and a couple of APIs to access WebViews after creation.
2025-02-15 10:06:36 -03:00
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
if (m_client_state.client)
m_client_state.client->unregister_view(m_client_state.page_index);
}
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 16:27:17 -03:00
WebContentClient& ViewImplementation::client()
{
VERIFY(m_client_state.client);
return *m_client_state.client;
}
WebContentClient const& ViewImplementation::client() const
{
VERIFY(m_client_state.client);
return *m_client_state.client;
}
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
u64 ViewImplementation::page_id() const
{
VERIFY(m_client_state.client);
return m_client_state.page_index;
}
LibWebView: Integrate bookmarks into the application menus and settings This adds application menus and actions to display and manage bookmarks. These menus will be used by the UIs to generate concrete widgets.
2026-03-22 12:44:54 -03:00
void ViewImplementation::set_url(URL::URL url)
{
if (m_url == url)
return;
LibWebView: Persist and restore zoom level per host Remember the zoom level for each host so that returning to a site restores the zoom the user previously chose, matching what other browsers have done for years. When the user zooms in, zooms out, or resets the zoom, the resulting level is written to Settings keyed by the current page's host. On navigation, when a view's URL host changes, the stored level for the new host is applied (or the global default if there is no override). Per-host zoom changes are broadcast through the SettingsObserver so that two tabs viewing the same host stay in sync as soon as the user adjusts zoom in either one. Zoom changes from within the page (such as internals.setBrowserZoom hook) and the WebContent restart path do not persist, only user-initiated zoom changes do.
2026-05-04 15:59:22 -03:00
auto previous_host = current_host();
LibWebView: Integrate bookmarks into the application menus and settings This adds application menus and actions to display and manage bookmarks. These menus will be used by the UIs to generate concrete widgets.
2026-03-22 12:44:54 -03:00
m_url = move(url);
update_bookmark_action();
LibWebView: Persist and restore zoom level per host Remember the zoom level for each host so that returning to a site restores the zoom the user previously chose, matching what other browsers have done for years. When the user zooms in, zooms out, or resets the zoom, the resulting level is written to Settings keyed by the current page's host. On navigation, when a view's URL host changes, the stored level for the new host is applied (or the global default if there is no override). Per-host zoom changes are broadcast through the SettingsObserver so that two tabs viewing the same host stay in sync as soon as the user adjusts zoom in either one. Zoom changes from within the page (such as internals.setBrowserZoom hook) and the WebContent restart path do not persist, only user-initiated zoom changes do.
2026-05-04 15:59:22 -03:00
if (current_host() != previous_host)
apply_zoom_for_current_host();
LibWebView: Integrate bookmarks into the application menus and settings This adds application menus and actions to display and manage bookmarks. These menus will be used by the UIs to generate concrete widgets.
2026-03-22 12:44:54 -03:00
}
void ViewImplementation::set_favicon(Badge<WebContentClient>, Gfx::Bitmap const& favicon)
{
m_favicon_base64_png.clear();
if (auto favicon_png = Gfx::PNGWriter::encode(favicon); !favicon_png.is_error()) {
if (auto favicon_base64_png = encode_base64(favicon_png.value().bytes()); !favicon_base64_png.is_error())
m_favicon_base64_png = favicon_base64_png.release_value();
}
LibWebView: Persist page metadata in history Record visits as soon as a page produces useful metadata such as a title or favicon so pages that never finish loading still become autocomplete candidates. Store favicons in the history schema from the start instead of introducing an upgrade path inside this series, and cover persisted metadata behavior in TestHistoryStore.
2026-04-11 19:33:00 -03:00
if (m_favicon_base64_png.has_value()) {
LibWebView: Integrate bookmarks into the application menus and settings This adds application menus and actions to display and manage bookmarks. These menus will be used by the UIs to generate concrete widgets.
2026-03-22 12:44:54 -03:00
Application::bookmark_store().update_favicon(m_url, *m_favicon_base64_png);
LibWeb+LibWebView: Preserve crashed page URLs on crash Load the browser-generated crash page as a synthetic response for the URL that was active when WebContent exited. This keeps the session history entry, response URL, and created Document aligned with the same navigation URL, so reload targets the original page without creating a local document for an HTTP(S) history entry. Suppress history metadata updates from the generated page and declare an inert rel=icon. Fallback favicon loading now follows the HTML condition that no link with the icon keyword exists, which avoids the credentialed /favicon.ico request from the crashed origin.
2026-05-20 11:42:08 -03:00
if (!m_should_suppress_history_for_current_load)
Application::history_store().update_favicon(m_url, *m_favicon_base64_png);
LibWebView: Persist page metadata in history Record visits as soon as a page produces useful metadata such as a title or favicon so pages that never finish loading still become autocomplete candidates. Store favicons in the history schema from the start instead of introducing an upgrade path inside this series, and cover persisted metadata behavior in TestHistoryStore.
2026-04-11 19:33:00 -03:00
}
LibWebView: Integrate bookmarks into the application menus and settings This adds application menus and actions to display and manage bookmarks. These menus will be used by the UIs to generate concrete widgets.
2026-03-22 12:44:54 -03:00
if (on_favicon_change)
on_favicon_change(favicon);
}
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
void ViewImplementation::create_new_process_for_cross_site_navigation(URL::URL const& url, Variant<Empty, String, Web::HTML::POSTResource> document_resource, Web::Bindings::NavigationHistoryBehavior history_handling)
LibWeb+LibWebView+WebContent: Begin implementing simple site islotation Site isolation is a common technique to reduce the chance that malicious sites can access data from other sites. When the user navigates, we now check if the target site is the same as the current site. If not, we instruct the UI to perform the navigation in a new WebContent process. The phrase "site" here is defined as the public suffix of the URL plus one level. This means that navigating from "www.example.com" to "sub.example.com" remains in the same process. There's plenty of room for optimization around this. For example, we can create a spare WebContent process ahead of time to hot-swap the target site. We can also create a policy to keep the navigated-from process around, in case the user quickly navigates back.
2025-03-09 12:40:34 -03:00
{
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
dump_session_history("before-process-swap"sv);
m_webdriver_pending_navigation_url = url;
LibWebView: Preserve old frame across process swaps Keep the outgoing front bitmap as the backup image before replacing the WebContent process for cross-site navigation. This lets the view keep painting the old page until the new process presents its first frame, rather than falling back to a flat background during loading.
2026-05-26 20:39:43 -03:00
if (m_client_state.has_usable_bitmap) {
// Keep showing the old page until the new WebContent process paints its first frame.
m_backup_shared_image_buffer = move(m_client_state.front_bitmap.shared_image_buffer);
m_backup_bitmap_size = m_client_state.front_bitmap.last_painted_size;
}
LibWebView: Unregister view before creating a new WebContent process If a did_paint message is in-flight and we create a new process when navigating to another website, we would still have the view registered with the client when eventually the stale did_paint message is handled. In server_did_paint, we retrieve the client which points to the new process, not the original process the view was registered for. At that point, there might not be any queued rasterization tasks in the RenderingThread for the new process, causing a crash because of: VERIFY(m_queued_rasterization_tasks >= 1 && ..); Fix this by unregistering the view before proceeding with a new WebContent process.
2026-01-30 04:55:00 -03:00
if (m_client_state.client) {
m_client_state.client->unregister_view(m_client_state.page_index);
}
LibWeb+LibWebView+WebContent: Begin implementing simple site islotation Site isolation is a common technique to reduce the chance that malicious sites can access data from other sites. When the user navigates, we now check if the target site is the same as the current site. If not, we instruct the UI to perform the navigation in a new WebContent process. The phrase "site" here is defined as the public suffix of the URL plus one level. This means that navigating from "www.example.com" to "sub.example.com" remains in the same process. There's plenty of room for optimization around this. For example, we can create a spare WebContent process ahead of time to hot-swap the target site. We can also create a policy to keep the navigated-from process around, in case the user quickly navigates back.
2025-03-09 12:40:34 -03:00
initialize_client();
VERIFY(m_client_state.client);
test-web: Handle WebContent process changes during cross-site navigation Commit 84db5d8c1c7254112a3a004feaba205404011a73 introduced the ability to load tests over an http:// URL instead of a file:// URL. Each time this happens, we switch to a new WebContent process due to site isolation. Our WebContent output capture was not handling this. For some reason, this was causing a wide array of test failures and timeouts. Often, the failures were accompanied by the content of the files loaded over HTTP being dumped to stdout. It's not quite clear what was going on here.
2026-02-20 12:21:22 -03:00
if (on_web_content_process_change_for_cross_site_navigation)
on_web_content_process_change_for_cross_site_navigation();
LibWeb+LibWebView+WebContent: Begin implementing simple site islotation Site isolation is a common technique to reduce the chance that malicious sites can access data from other sites. When the user navigates, we now check if the target site is the same as the current site. If not, we instruct the UI to perform the navigation in a new WebContent process. The phrase "site" here is defined as the public suffix of the URL plus one level. This means that navigating from "www.example.com" to "sub.example.com" remains in the same process. There's plenty of room for optimization around this. For example, we can create a spare WebContent process ahead of time to hot-swap the target site. We can also create a policy to keep the navigated-from process around, in case the user quickly navigates back.
2025-03-09 12:40:34 -03:00
handle_resize();
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
auto ui_session_history_already_points_to_url = false;
if (should_manage_session_history_in_ui_process()) {
if (auto const* current_entry = m_session_history.current_entry(); current_entry && current_entry->url == url)
ui_session_history_already_points_to_url = true;
if (m_pending_session_history_traversal.has_value() && m_pending_session_history_traversal->will_replace_web_content_process)
m_pending_session_history_traversal->stage = PendingSessionHistoryTraversal::Stage::ReplacingWebContentProcess;
if (m_pending_session_history_navigation.has_value())
m_pending_session_history_navigation->web_content_restore_mode = PendingSessionHistoryNavigation::WebContentRestoreMode::RestoreFromUIProcess;
m_current_web_content_session_history_matches_mirror = false;
m_session_history.forget_web_content_state();
m_pending_web_content_session_history_seed.waiting_for_ack = false;
m_pending_web_content_session_history_seed.should_send_entries = true;
m_pending_web_content_session_history_seed.ignore_updates_until_seed = true;
}
auto seed_replacement_process_before_load_if_possible = [&] {
if (!should_manage_session_history_in_ui_process())
return false;
if (!m_pending_web_content_session_history_seed.should_send_entries)
return false;
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
if (m_session_history_entry_url_loading_from_ui_process.has_value())
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
return false;
if (m_session_history.current_step_to_restore_after_loading_top_level_entry().has_value())
return false;
seed_web_content_session_history_from_ui_process();
return true;
};
if (ui_session_history_already_points_to_url) {
m_should_suppress_history_for_current_load = false;
m_should_suppress_history_for_next_load = false;
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
if (!m_session_history_entry_url_loading_from_ui_process.has_value())
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
m_pending_web_content_session_history_seed.step_after_loading_top_level_entry = m_session_history.current_step_to_restore_after_loading_top_level_entry();
set_url(url);
auto seeded_replacement_process_before_load = seed_replacement_process_before_load_if_possible();
auto web_content_history_handling = seeded_replacement_process_before_load ? Web::Bindings::NavigationHistoryBehavior::Replace : history_handling;
dump_session_history("process-swap-load-existing-ui-entry"sv);
client().async_load_url_with_document_resource(page_id(), url, document_resource, web_content_history_handling);
} else {
m_should_suppress_history_for_current_load = false;
m_should_suppress_history_for_next_load = false;
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
if (should_manage_session_history_in_ui_process() && !m_session_history_entry_url_loading_from_ui_process.has_value()) {
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
if (m_session_history.current_entry()) {
m_pending_session_history_navigation = PendingSessionHistoryNavigation {
url,
m_session_history,
PendingSessionHistoryNavigation::WebContentRestoreMode::RestoreFromUIProcess,
};
} else {
m_pending_session_history_navigation.clear();
}
if (history_handling == Web::Bindings::NavigationHistoryBehavior::Replace)
m_session_history.replace_current_entry(url, document_resource);
else
m_session_history.navigate(url, document_resource);
m_current_web_content_session_history_matches_mirror = false;
update_navigation_action_state();
}
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
if (!m_session_history_entry_url_loading_from_ui_process.has_value())
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
m_pending_web_content_session_history_seed.step_after_loading_top_level_entry = m_session_history.current_step_to_restore_after_loading_top_level_entry();
set_url(url);
auto seeded_replacement_process_before_load = seed_replacement_process_before_load_if_possible();
auto web_content_history_handling = seeded_replacement_process_before_load ? Web::Bindings::NavigationHistoryBehavior::Replace : history_handling;
dump_session_history("load"sv);
client().async_load_url_with_document_resource(page_id(), url, document_resource, web_content_history_handling);
}
dump_session_history("after-process-swap-load"sv);
LibWeb+LibWebView+WebContent: Begin implementing simple site islotation Site isolation is a common technique to reduce the chance that malicious sites can access data from other sites. When the user navigates, we now check if the target site is the same as the current site. If not, we instruct the UI to perform the navigation in a new WebContent process. The phrase "site" here is defined as the public suffix of the URL plus one level. This means that navigating from "www.example.com" to "sub.example.com" remains in the same process. There's plenty of room for optimization around this. For example, we can create a spare WebContent process ahead of time to hot-swap the target site. We can also create a policy to keep the navigated-from process around, in case the user quickly navigates back.
2025-03-09 12:40:34 -03:00
}
Ladybird+LibWebView: Move most of paint handling to LibWebView Storing the backup bitmap is the same across Browser and Ladybird. Just peform that work in LibWebView, and handle only the implementation- specific nuances within the browsers.
2023-05-20 11:50:05 -03:00
void ViewImplementation::server_did_paint(Badge<WebContentClient>, i32 bitmap_id, Gfx::IntSize size)
{
LibWeb: Present frames through Compositor IPC Introduce a dedicated Compositor IPC channel between the UI process and WebContent. Use it for backing-store setup, presented bitmap delivery, and bitmap-specific ready_to_paint acknowledgements. This makes CompositorThread the single owner of frame presentation bookkeeping before async scrolling starts producing frames without the main thread. Remove old paint and backing-store messages from WebContentClient and PageClient so the UI process no longer observes two presentation protocols.
2026-05-11 16:02:29 -03:00
bool did_swap_bitmap = false;
LibWebView+WebContent: Drive repainting from WebContent process With this change, chrome no longer has to ask the WebContent process to paint the next frame into a specified bitmap. Instead, it allocates bitmaps and sends them to WebContent, which then lets chrome know when the painting is done. This work is a preparation to move the execution of painting commands into a separate thread. Now, it is much easier to start working on the next frame while the current one is still rendering. This is because WebContent does not have to inform chrome that the current frame is ready before it can request the next frame. Additionally, as a side bonus, we can now eliminate the did_invalidate_content_rect and did_change_selection IPC calls. These were used solely for the purpose of informing chrome that it needed to request a repaint.
2023-12-21 18:58:54 -03:00
if (m_client_state.back_bitmap.id == bitmap_id) {
m_client_state.has_usable_bitmap = true;
m_client_state.back_bitmap.last_painted_size = size.to_type<Web::DevicePixels>();
swap(m_client_state.back_bitmap, m_client_state.front_bitmap);
Everywhere: Replace SharedBackingStore with Gfx::SharedImage Generalize the backing store sharing abstraction into SharedImage, which represents shared GPU memory independently of Skia and can be used to share memory between different processes or different GPU contexts.
2026-04-07 13:35:26 -03:00
m_backup_shared_image_buffer = nullptr;
LibWeb: Present frames through Compositor IPC Introduce a dedicated Compositor IPC channel between the UI process and WebContent. Use it for backing-store setup, presented bitmap delivery, and bitmap-specific ready_to_paint acknowledgements. This makes CompositorThread the single owner of frame presentation bookkeeping before async scrolling starts producing frames without the main thread. Remove old paint and backing-store messages from WebContentClient and PageClient so the UI process no longer observes two presentation protocols.
2026-05-11 16:02:29 -03:00
did_swap_bitmap = true;
Ladybird+LibWebView: Move most of paint handling to LibWebView Storing the backup bitmap is the same across Browser and Ladybird. Just peform that work in LibWebView, and handle only the implementation- specific nuances within the browsers.
2023-05-20 11:50:05 -03:00
}
LibWebView+WebContent: Let the WebView client broadcast when it painted When the WebContent process has painted to its shared bitmaps, it sends a synchronous IPC to the browser process to let the chrome paint. It is synchronous to ensure the WC process doesn't paint onto the backing bitmap again while it is being displayed. However, this can cause a crash at exit if the browser process quits while the WC process is waiting for a response to this IPC. This patch makes the painting logic asynchronous by letting the browser process broadcast when it has finished handling the paint IPC. The WC process will not paint anything again until it receives that message. If it had tried to repaint while waiting for that message, that paint will be deferred until it arrives.
2024-01-07 12:35:45 -03:00
LibWeb: Add compositor debug logging Trace the compositor state transitions that matter once presentation and async scrolling share one path: page registration, backing-store swaps, did_paint delivery, ready_to_paint acknowledgements, wheel admission, and deferred presents waiting for reusable bitmaps. Keep the logs under COMPOSITOR_DEBUG and use the [Compositor] prefix consistently. The trace is about ownership and backpressure instead of dumping every wheel event detail, so stalls can be diagnosed without reintroducing noisy async-scrolling-only logging.
2026-05-11 16:48:43 -03:00
dbgln_if(COMPOSITOR_DEBUG, "[Compositor] UI received presented bitmap {} for page {} size={}x{} did_swap={} front={} back={}",
bitmap_id, page_id(), size.width(), size.height(), did_swap_bitmap, m_client_state.front_bitmap.id, m_client_state.back_bitmap.id);
LibWeb: Present frames through Compositor IPC Introduce a dedicated Compositor IPC channel between the UI process and WebContent. Use it for backing-store setup, presented bitmap delivery, and bitmap-specific ready_to_paint acknowledgements. This makes CompositorThread the single owner of frame presentation bookkeeping before async scrolling starts producing frames without the main thread. Remove old paint and backing-store messages from WebContentClient and PageClient so the UI process no longer observes two presentation protocols.
2026-05-11 16:02:29 -03:00
client().notify_presented_bitmap_ready_to_paint(page_id(), bitmap_id);
if (did_swap_bitmap && on_ready_to_paint)
on_ready_to_paint();
Ladybird+LibWebView: Move most of paint handling to LibWebView Storing the backup bitmap is the same across Browser and Ladybird. Just peform that work in LibWebView, and handle only the implementation- specific nuances within the browsers.
2023-05-20 11:50:05 -03:00
}
UI/AppKit: Inform WebContent of the UI window position/size This is required for APIs like window.screenX, as well as for WebDriver and WPT.
2024-10-28 08:48:49 -03:00
void ViewImplementation::set_window_position(Gfx::IntPoint position)
{
client().async_set_window_position(m_client_state.page_index, position.to_type<Web::DevicePixels>());
}
void ViewImplementation::set_window_size(Gfx::IntSize size)
{
client().async_set_window_size(m_client_state.page_index, size.to_type<Web::DevicePixels>());
}
LibWeb+WebContent+WebDriver+UI: Make window rect updates asynchronous It's currently possible for window size/position updates to hang, as the underlying IPCs are synchronous. This updates the WebDriver endpoint to be async, to unblock the WebContent process while the update is ongoing. The UI process is now responsible for informing WebContent when the update is complete.
2024-10-29 00:37:11 -03:00
void ViewImplementation::did_update_window_rect()
{
client().async_did_update_window_rect(m_client_state.page_index);
}
LibWebView+WebContent+UI: Remember the current system visibility state We will want to re-inform WebContent of the system visibility state when we create a new process after a crash. This changes the IPC to just send the enum value directly, instead of a boolean, so that we can just store that enum value directly on the ViewImplementation class.
2024-11-13 13:24:16 -03:00
void ViewImplementation::set_system_visibility_state(Web::HTML::VisibilityState visibility_state)
{
UI: Update page visibility when switching tabs Send hidden and visible system visibility updates from explicit tab switch paths instead of relying only on widget show and hide events. Tab containers can keep inactive web views mapped, which leaves documents visible from WebContent's perspective and lets animated images keep running in background tabs. Use AppKit window occlusion state rather than the app-wide active tab. That keeps still-visible background windows in the visible document state. Avoid resending duplicate visibility updates from ViewImplementation so existing widget visibility notifications remain harmless.
2026-05-27 08:19:17 -03:00
if (m_system_visibility_state == visibility_state)
return;
LibWebView+WebContent+UI: Remember the current system visibility state We will want to re-inform WebContent of the system visibility state when we create a new process after a crash. This changes the IPC to just send the enum value directly, instead of a boolean, so that we can just store that enum value directly on the ViewImplementation class.
2024-11-13 13:24:16 -03:00
m_system_visibility_state = visibility_state;
client().async_set_system_visibility_state(m_client_state.page_index, m_system_visibility_state);
}
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
void ViewImplementation::load(URL::URL const& url, Web::Bindings::NavigationHistoryBehavior history_handling)
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 17:30:06 -03:00
{
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
m_is_showing_crash_page = false;
LibWeb+LibWebView: Preserve crashed page URLs on crash Load the browser-generated crash page as a synthetic response for the URL that was active when WebContent exited. This keeps the session history entry, response URL, and created Document aligned with the same navigation URL, so reload targets the original page without creating a local document for an HTTP(S) history entry. Suppress history metadata updates from the generated page and declare an inert rel=icon. Fallback favicon loading now follows the HTML condition that no link with the icon keyword exists, which avoids the credentialed /favicon.ico request from the crashed origin.
2026-05-20 11:42:08 -03:00
m_should_suppress_history_for_current_load = false;
m_should_suppress_history_for_next_load = false;
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
auto should_defer_ui_process_history_update = false;
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
if (!m_session_history_entry_url_loading_from_ui_process.has_value())
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
abandon_pending_web_content_session_history_seed();
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
if (should_manage_session_history_in_ui_process() && !m_session_history_entry_url_loading_from_ui_process.has_value()) {
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
m_pending_session_history_traversal.clear();
auto const* current_entry = m_session_history.current_entry();
auto is_javascript_navigation = url.scheme() == "javascript"sv;
should_defer_ui_process_history_update = is_javascript_navigation;
if (current_entry && !is_javascript_navigation)
m_pending_session_history_navigation = PendingSessionHistoryNavigation { url, m_session_history };
else
m_pending_session_history_navigation.clear();
if (!is_javascript_navigation) {
auto ui_process_history_handling = history_handling;
if (ui_process_history_handling == Web::Bindings::NavigationHistoryBehavior::Auto) {
// https://html.spec.whatwg.org/multipage/browsing-the-web.html#navigate
// If url equals navigable's active document's URL, and
// initiatorOriginSnapshot is same origin with targetNavigable's
// active document's origin, then set historyHandling to "replace".
if (current_entry && current_entry->url == url)
ui_process_history_handling = Web::Bindings::NavigationHistoryBehavior::Replace;
else
ui_process_history_handling = Web::Bindings::NavigationHistoryBehavior::Push;
}
if (ui_process_history_handling == Web::Bindings::NavigationHistoryBehavior::Replace)
m_session_history.replace_current_entry(url, Empty {});
else
m_session_history.navigate(url);
m_current_web_content_session_history_matches_mirror = false;
update_navigation_action_state();
}
}
if (!should_defer_ui_process_history_update)
set_url(url);
dump_session_history("load"sv);
client().async_load_url(page_id(), url, history_handling);
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 17:30:06 -03:00
}
Userland+Ladybird: Always specify url to be about:srcdoc in load_html() After moving to navigables, we started reusing the code that populates session history entries with the srcdoc attribute value from iframes in `Page::load_html()` for loading HTML. This change addresses a crash in `determine_the_origin` which occurred because this method expected the URL to be `about:srcdoc` if we also provided HTML content (previously, it was the URL passed along with the HTML content into `load_html()`).
2023-09-17 12:12:17 -03:00
void ViewImplementation::load_html(StringView html)
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 17:30:06 -03:00
{
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
m_is_showing_crash_page = false;
LibWeb+LibWebView: Preserve crashed page URLs on crash Load the browser-generated crash page as a synthetic response for the URL that was active when WebContent exited. This keeps the session history entry, response URL, and created Document aligned with the same navigation URL, so reload targets the original page without creating a local document for an HTTP(S) history entry. Suppress history metadata updates from the generated page and declare an inert rel=icon. Fallback favicon loading now follows the HTML condition that no link with the icon keyword exists, which avoids the credentialed /favicon.ico request from the crashed origin.
2026-05-20 11:42:08 -03:00
m_should_suppress_history_for_current_load = false;
m_should_suppress_history_for_next_load = false;
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
abandon_pending_web_content_session_history_seed();
if (should_manage_session_history_in_ui_process()) {
m_current_web_content_session_history_matches_mirror = false;
m_session_history.forget_web_content_state();
}
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_load_html(page_id(), html);
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 17:30:06 -03:00
}
LibWeb+LibWebView: Preserve crashed page URLs on crash Load the browser-generated crash page as a synthetic response for the URL that was active when WebContent exited. This keeps the session history entry, response URL, and created Document aligned with the same navigation URL, so reload targets the original page without creating a local document for an HTTP(S) history entry. Suppress history metadata updates from the generated page and declare an inert rel=icon. Fallback favicon loading now follows the HTML condition that no link with the icon keyword exists, which avoids the credentialed /favicon.ico request from the crashed origin.
2026-05-20 11:42:08 -03:00
void ViewImplementation::load_crash_page_html(StringView html, URL::URL const& crashed_url)
{
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
m_is_showing_crash_page = true;
LibWeb+LibWebView: Preserve crashed page URLs on crash Load the browser-generated crash page as a synthetic response for the URL that was active when WebContent exited. This keeps the session history entry, response URL, and created Document aligned with the same navigation URL, so reload targets the original page without creating a local document for an HTTP(S) history entry. Suppress history metadata updates from the generated page and declare an inert rel=icon. Fallback favicon loading now follows the HTML condition that no link with the icon keyword exists, which avoids the credentialed /favicon.ico request from the crashed origin.
2026-05-20 11:42:08 -03:00
m_should_suppress_history_for_current_load = true;
m_should_suppress_history_for_next_load = true;
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
abandon_pending_web_content_session_history_seed();
if (should_manage_session_history_in_ui_process()) {
m_current_web_content_session_history_matches_mirror = false;
m_session_history.forget_web_content_state();
}
LibWeb+LibWebView: Preserve crashed page URLs on crash Load the browser-generated crash page as a synthetic response for the URL that was active when WebContent exited. This keeps the session history entry, response URL, and created Document aligned with the same navigation URL, so reload targets the original page without creating a local document for an HTTP(S) history entry. Suppress history metadata updates from the generated page and declare an inert rel=icon. Fallback favicon loading now follows the HTML condition that no link with the icon keyword exists, which avoids the credentialed /favicon.ico request from the crashed origin.
2026-05-20 11:42:08 -03:00
set_url(crashed_url);
client().async_load_html_with_url(page_id(), html, crashed_url);
}
LibWebView+UI: Show an error page when we cannot sanitize a URL Previously, if search was disabled, entering non-URL text would just silently drop the search query (and on Qt, we would reload the current URL). We now detect that the query did not result in a navigation and load an error page instead, which directs the user to enable search.
2026-04-24 09:36:55 -03:00
void ViewImplementation::load_navigation_error_page(StringView text)
{
auto message = MUST(String::formatted("Failed to load \"{}\"", text));
StringBuilder builder;
LibWeb+LibWebView: Preserve crashed page URLs on crash Load the browser-generated crash page as a synthetic response for the URL that was active when WebContent exited. This keeps the session history entry, response URL, and created Document aligned with the same navigation URL, so reload targets the original page without creating a local document for an HTTP(S) history entry. Suppress history metadata updates from the generated page and declare an inert rel=icon. Fallback favicon loading now follows the HTML condition that no link with the icon keyword exists, which avoids the credentialed /favicon.ico request from the crashed origin.
2026-05-20 11:42:08 -03:00
builder.appendff(ERROR_HTML_HEADER, ""sv, ERROR_SVG, message);
LibWebView+UI: Show an error page when we cannot sanitize a URL Previously, if search was disabled, entering non-URL text would just silently drop the search query (and on Qt, we would reload the current URL). We now detect that the query did not result in a navigation and load an error page instead, which directs the user to enable search.
2026-04-24 09:36:55 -03:00
builder.append("<p>If you were trying to enter a search query, please enable search in <a href=\"about:settings#search\">settings</a>.</p>"sv);
builder.append(ERROR_HTML_FOOTER);
load_html(builder.string_view());
}
LibWeb+LibWebView+WebContent: Add an IPC call for Navigable::reload()
2024-04-13 13:51:27 -03:00
void ViewImplementation::reload()
{
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
if (should_manage_session_history_in_ui_process() && m_is_showing_crash_page) {
m_is_showing_crash_page = false;
m_should_suppress_history_for_current_load = false;
m_should_suppress_history_for_next_load = false;
prepare_to_seed_web_content_session_history_from_ui_process();
restore_current_session_history_entry_from_ui_process();
return;
}
m_is_showing_crash_page = false;
LibWeb+LibWebView: Preserve crashed page URLs on crash Load the browser-generated crash page as a synthetic response for the URL that was active when WebContent exited. This keeps the session history entry, response URL, and created Document aligned with the same navigation URL, so reload targets the original page without creating a local document for an HTTP(S) history entry. Suppress history metadata updates from the generated page and declare an inert rel=icon. Fallback favicon loading now follows the HTML condition that no link with the icon keyword exists, which avoids the credentialed /favicon.ico request from the crashed origin.
2026-05-20 11:42:08 -03:00
m_should_suppress_history_for_current_load = false;
m_should_suppress_history_for_next_load = false;
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
abandon_pending_web_content_session_history_seed();
if (should_manage_session_history_in_ui_process()) {
m_session_history.mark_current_entry_reload_pending();
m_current_web_content_session_history_matches_mirror = false;
update_navigation_action_state();
dump_session_history("reload-mark-current-entry-reload-pending"sv);
}
LibWeb+LibWebView+WebContent: Add an IPC call for Navigable::reload()
2024-04-13 13:51:27 -03:00
client().async_reload(page_id());
}
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
ViewImplementation::HistoryTraversalOutcome ViewImplementation::traverse_the_history_by_delta(
int delta,
CheckForCancelation check_for_cancelation,
Function<void(HistoryTraversalOutcome)> on_cancelation_check_complete)
{
if (!should_manage_session_history_in_ui_process()) {
m_should_suppress_history_for_current_load = false;
m_should_suppress_history_for_next_load = false;
m_webdriver_pending_navigation_completes_with_session_history_update = false;
client().async_traverse_the_history_by_delta(page_id(), delta);
return {
.status = HistoryTraversalStatus::Started,
.will_change_top_level_entry = true,
};
}
// https://html.spec.whatwg.org/multipage/browsing-the-web.html#traverse-the-history-by-a-delta
// Let allSteps be the result of getting all used history steps for traversable.
// Let currentStepIndex be the index of traversable's current session history step within allSteps.
// Let targetStepIndex be currentStepIndex plus delta.
//
// AD-HOC: Browser UI calls do not pass sourceDocument. Since the UI process owns the top-level session history
// mirror, it resolves targetStepIndex before asking WebContent to apply or precheck the resulting
// traverse history step.
auto target = m_session_history.traversal_target_for_delta(delta);
if (!target.has_value()) {
dump_session_history("traverse-no-entry"sv);
return { .status = HistoryTraversalStatus::NoEntry };
}
LibWeb+LibWebView: Preserve crashed page URLs on crash Load the browser-generated crash page as a synthetic response for the URL that was active when WebContent exited. This keeps the session history entry, response URL, and created Document aligned with the same navigation URL, so reload targets the original page without creating a local document for an HTTP(S) history entry. Suppress history metadata updates from the generated page and declare an inert rel=icon. Fallback favicon loading now follows the HTML condition that no link with the icon keyword exists, which avoids the credentialed /favicon.ico request from the crashed origin.
2026-05-20 11:42:08 -03:00
m_should_suppress_history_for_current_load = false;
m_should_suppress_history_for_next_load = false;
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
auto will_replace_web_content_process = !is_url_suitable_for_same_process_navigation(m_url, target->target_top_level_entry->url);
auto pending_traversal = PendingSessionHistoryTraversal {
.target_step = target->target_step,
.target_step_index = target->target_step_index,
.will_change_top_level_entry = target->changes_top_level_entry,
.will_replace_web_content_process = will_replace_web_content_process,
.on_cancelation_check_complete = nullptr,
};
auto web_content_can_apply_traversal = !m_pending_web_content_session_history_seed.should_send_entries
&& !m_pending_web_content_session_history_seed.ignore_updates_until_seed
&& !m_pending_web_content_session_history_seed.waiting_for_ack
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
&& !m_session_history_entry_url_loading_from_ui_process.has_value()
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
&& !m_pending_web_content_session_history_seed.step_after_loading_top_level_entry.has_value()
&& m_session_history.web_content_can_traverse_to(*target);
// If WebContent already has enough state to apply the traverse history step,
// let it run the spec algorithm directly.
if (web_content_can_apply_traversal && !will_replace_web_content_process) {
m_pending_session_history_traversal = move(pending_traversal);
m_webdriver_pending_navigation_url = target->target_top_level_entry->url;
if (auto const* current_entry = m_session_history.current_entry()) {
m_webdriver_pending_navigation_completes_with_session_history_update = current_entry->document_state.id != 0
&& current_entry->document_state.id == target->target_top_level_entry->document_state.id;
} else {
m_webdriver_pending_navigation_completes_with_session_history_update = false;
}
dump_session_history("traverse-delegate-to-webcontent"sv);
client().async_traverse_the_history_to_step(page_id(), target->target_step);
return {
.status = HistoryTraversalStatus::Started,
.will_replace_web_content_process = will_replace_web_content_process,
.will_change_top_level_entry = target->changes_top_level_entry,
};
}
// https://html.spec.whatwg.org/multipage/browsing-the-web.html#apply-the-history-step
// If checkForCancelation is true, and the result of checking if unloading is canceled given
// navigablesCrossingDocuments, traversable, targetStep, and userInvolvement is not "continue", then return that
// result.
//
// AD-HOC: If WebContent cannot apply the step itself, the UI still asks it to run that precheck before moving
// the UI-owned history mirror and loading or reseeding WebContent from that state. A renderer-initiated
// traversal can report that this already happened, but only trust that precheck if WebContent can
// traverse to the same target step in the UI-owned history mirror.
auto needs_cancelation_check = check_for_cancelation == CheckForCancelation::Yes
|| (check_for_cancelation == CheckForCancelation::IfWebContentCannotTraverseTarget && !web_content_can_apply_traversal);
if (needs_cancelation_check) {
pending_traversal.stage = PendingSessionHistoryTraversal::Stage::CheckingCancelation;
pending_traversal.cancelation_check_request_id = m_next_traverse_history_step_cancelation_check_request_id++;
pending_traversal.on_cancelation_check_complete = move(on_cancelation_check_complete);
auto request_id = pending_traversal.cancelation_check_request_id;
m_pending_session_history_traversal = move(pending_traversal);
client().async_check_if_traverse_history_step_is_canceled(page_id(), request_id, target->target_step);
dump_session_history("traverse-fallback-check-cancelation"sv);
return {
.status = HistoryTraversalStatus::Started,
.will_replace_web_content_process = will_replace_web_content_process,
.will_change_top_level_entry = target->changes_top_level_entry,
.waiting_for_cancelation_check = true,
};
}
pending_traversal.stage = PendingSessionHistoryTraversal::Stage::LoadingEntryFromUIProcess;
m_pending_session_history_traversal = move(pending_traversal);
load_session_history_traversal_target_from_ui_process(*target, "traverse-fallback-load"sv);
return {
.status = HistoryTraversalStatus::Started,
.will_replace_web_content_process = will_replace_web_content_process,
.will_change_top_level_entry = target->changes_top_level_entry,
};
LibWeb+LibWebView+WebContent: Add traverse_history_by_delta() IPC call
2024-04-13 17:33:48 -03:00
}
UI/Qt: Add navigation history menus Show native history menus when users right-click or long-press the back and forward toolbar buttons. Populate entries from the UI-process session history mirror, using saved history titles and favicons when available and falling back to the URL and globe icon otherwise. Share the Qt base64 PNG icon helper so bookmark menus and navigation history menus render stored favicons consistently.
2026-06-15 20:35:03 -03:00
Vector<ViewImplementation::SessionHistoryTraversalMenuItem> ViewImplementation::session_history_traversal_menu_items(int direction) const
{
VERIFY(direction == -1 || direction == 1);
auto current_used_step_index = m_session_history.current_used_step_index();
if (!current_used_step_index.has_value())
return {};
Vector<SessionHistoryTraversalMenuItem> items;
auto append_item = [&](size_t target_step_index, TraversableSessionHistory::Entry const& target_entry) {
auto history_entry = Application::history_store().entry_for_url(target_entry.url);
auto url = target_entry.url.serialize();
auto title = history_entry.has_value() && history_entry->title.has_value() && !history_entry->title->is_empty()
? move(*history_entry->title)
: url;
items.append({
static_cast<int>(target_step_index) - static_cast<int>(*current_used_step_index),
move(title),
move(url),
history_entry.has_value() ? move(history_entry->favicon_base64_png) : Optional<String> {},
});
};
if (direction < 0) {
for (size_t target_step_index = *current_used_step_index; target_step_index > 0; --target_step_index) {
auto target_step = m_session_history.step_at(target_step_index - 1);
if (!target_step.has_value())
continue;
auto const* target_entry = m_session_history.top_level_entry_for_step(*target_step);
if (!target_entry)
continue;
append_item(target_step_index - 1, *target_entry);
}
} else {
for (size_t target_step_index = *current_used_step_index + 1; target_step_index < m_session_history.used_step_count(); ++target_step_index) {
auto target_step = m_session_history.step_at(target_step_index);
if (!target_step.has_value())
continue;
auto const* target_entry = m_session_history.top_level_entry_for_step(*target_step);
if (!target_entry)
continue;
append_item(target_step_index, *target_entry);
}
}
return items;
}
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 16:49:49 -03:00
void ViewImplementation::zoom_in()
{
if (m_zoom_level >= ZOOM_MAX_LEVEL)
return;
LibWeb+WebContent: Allow WebContent to disentangle zoom from css pixels So Ladybird can paint scrollbar & resizer chrome at the same size regardless of zoom level while still respecting device pixel ratio
2026-01-05 22:05:10 -03:00
m_zoom_level = round_to<int>((m_zoom_level + ZOOM_STEP) * 100) / 100.0;
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 16:49:49 -03:00
update_zoom();
LibWebView: Persist and restore zoom level per host Remember the zoom level for each host so that returning to a site restores the zoom the user previously chose, matching what other browsers have done for years. When the user zooms in, zooms out, or resets the zoom, the resulting level is written to Settings keyed by the current page's host. On navigation, when a view's URL host changes, the stored level for the new host is applied (or the global default if there is no override). Per-host zoom changes are broadcast through the SettingsObserver so that two tabs viewing the same host stay in sync as soon as the user adjusts zoom in either one. Zoom changes from within the page (such as internals.setBrowserZoom hook) and the WebContent restart path do not persist, only user-initiated zoom changes do.
2026-05-04 15:59:22 -03:00
Application::settings().set_zoom_for_host(current_host(), m_zoom_level);
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 16:49:49 -03:00
}
void ViewImplementation::zoom_out()
{
if (m_zoom_level <= ZOOM_MIN_LEVEL)
return;
LibWeb+WebContent: Allow WebContent to disentangle zoom from css pixels So Ladybird can paint scrollbar & resizer chrome at the same size regardless of zoom level while still respecting device pixel ratio
2026-01-05 22:05:10 -03:00
m_zoom_level = round_to<int>((m_zoom_level - ZOOM_STEP) * 100) / 100.0;
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 16:49:49 -03:00
update_zoom();
LibWebView: Persist and restore zoom level per host Remember the zoom level for each host so that returning to a site restores the zoom the user previously chose, matching what other browsers have done for years. When the user zooms in, zooms out, or resets the zoom, the resulting level is written to Settings keyed by the current page's host. On navigation, when a view's URL host changes, the stored level for the new host is applied (or the global default if there is no override). Per-host zoom changes are broadcast through the SettingsObserver so that two tabs viewing the same host stay in sync as soon as the user adjusts zoom in either one. Zoom changes from within the page (such as internals.setBrowserZoom hook) and the WebContent restart path do not persist, only user-initiated zoom changes do.
2026-05-04 15:59:22 -03:00
Application::settings().set_zoom_for_host(current_host(), m_zoom_level);
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 16:49:49 -03:00
}
LibWeb+UI: Add internals API to set browser zoom
2024-12-23 18:15:06 -03:00
void ViewImplementation::set_zoom(double zoom_level)
{
m_zoom_level = max(ZOOM_MIN_LEVEL, min(zoom_level, ZOOM_MAX_LEVEL));
update_zoom();
}
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 16:49:49 -03:00
void ViewImplementation::reset_zoom()
{
LibWeb+WebContent: Allow WebContent to disentangle zoom from css pixels So Ladybird can paint scrollbar & resizer chrome at the same size regardless of zoom level while still respecting device pixel ratio
2026-01-05 22:05:10 -03:00
m_zoom_level = 1.0;
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 16:49:49 -03:00
update_zoom();
LibWeb+LibWebView+WebContent: Reset pinch-to-zoom state on Ctrl/Cmd+0
2025-10-09 15:29:12 -03:00
client().async_reset_zoom(m_client_state.page_index);
LibWebView: Persist and restore zoom level per host Remember the zoom level for each host so that returning to a site restores the zoom the user previously chose, matching what other browsers have done for years. When the user zooms in, zooms out, or resets the zoom, the resulting level is written to Settings keyed by the current page's host. On navigation, when a view's URL host changes, the stored level for the new host is applied (or the global default if there is no override). Per-host zoom changes are broadcast through the SettingsObserver so that two tabs viewing the same host stay in sync as soon as the user adjusts zoom in either one. Zoom changes from within the page (such as internals.setBrowserZoom hook) and the WebContent restart path do not persist, only user-initiated zoom changes do.
2026-05-04 15:59:22 -03:00
Application::settings().set_zoom_for_host(current_host(), m_zoom_level);
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 16:49:49 -03:00
}
LibWeb+LibWebView: Migrate Browser's input event handling to LibWebView The Serenity chrome is the only chrome thus far that sends all input key and mouse events to WebContent, including shortcut activations. This is necessary for all chromes - we must give web pages a chance to intercept input events before handling them ourselves. To make this easier for other chromes, this patch moves Serenity's input event handling to LibWebView. To do so, we add the Web::InputEvent type, which models the event data we need within LibWeb. Chromes will then be responsible for converting between this type and their native events. This class lives in LibWeb (rather than LibWebView) because the plan is to use it wholesale throughout the Page's event handler and across IPC. Right now, we still send the individual fields of the event over IPC, but it will be an easy refactor to send the event itself. We just can't do this until all chromes have been ported to this event queueing. Also note that we now only handle key input events back in the chrome. WebContent handles all mouse events that it possibly can. If it was not able to handle a mouse event, there's nothing for the chrome to do (i.e. there is no clicking, scrolling, etc. the chrome is able to do if the WebContent couldn't).
2024-03-04 00:07:49 -03:00
void ViewImplementation::enqueue_input_event(Web::InputEvent event)
{
LibWebView: Normalize wheel deltas to CSS pixels Platform wheel deltas describe movement in the view, not in page CSS pixels. Convert them by page zoom before dispatch so physical scrolling covers a smaller page area when zoomed in. Do this before the UI-side async scrolling shortcut so compositor scrolling and main-thread fallback scrolling use the same delta. Also avoid applying the Qt device pixel ratio while converting angle-only wheel input, since LibWeb later handles device-pixel scaling itself.
2026-05-31 22:07:38 -03:00
auto* mouse_event = event.get_pointer<Web::MouseEvent>();
Compositor: Handle pinch zoom asynchronously Apply pinch zoom deltas to the compositor's visual viewport transform so the currently presented display list can respond without waiting for the WebContent main thread. Keep the normal WebContent pinch event path so the real VisualViewport state and DOM-visible events catch up after. Only take the compositor path when async scrolling is enabled and there are no blocking wheel listeners, since pinch zoom dispatches a synthetic wheel event that script may cancel. Coalesce queued pinch events in WebContent so main-thread catch-up can adopt multiple gesture deltas together. Use the compositor visual viewport transform for wheel hit testing and consume wheel deltas as visual viewport pan while zoomed. Scale the handoff to layout viewport scrolling by the inverse visual viewport scale, so touchpad momentum does not jump when the visual viewport hits an edge.
2026-06-14 16:30:28 -03:00
auto* pinch_event = event.get_pointer<Web::PinchEvent>();
LibWebView: Normalize wheel deltas to CSS pixels Platform wheel deltas describe movement in the view, not in page CSS pixels. Convert them by page zoom before dispatch so physical scrolling covers a smaller page area when zoomed in. Do this before the UI-side async scrolling shortcut so compositor scrolling and main-thread fallback scrolling use the same delta. Also avoid applying the Qt device pixel ratio while converting angle-only wheel input, since LibWeb later handles device-pixel scaling itself.
2026-05-31 22:07:38 -03:00
if (mouse_event && mouse_event->type == Web::MouseEvent::Type::MouseWheel) {
mouse_event->wheel_delta_x /= zoom_level();
mouse_event->wheel_delta_y /= zoom_level();
}
if (Application::web_content_options().enable_async_scrolling == EnableAsyncScrolling::Yes
LibWebView: Route wheel bypasses over Compositor IPC Send the experimental UI-process wheel bypass to WebContent over the Compositor IPC connection instead of adding a separate async scrolling transport. This keeps bypass admission on the channel that owns bitmaps and ready_to_paint acknowledgements. If the compositor rejects the wheel, LibWebView falls back to regular input delivery. If it accepts, mark the queued DOM event as having already performed its default action so dispatch preserves ordering without scrolling twice.
2026-05-11 16:45:34 -03:00
&& m_client_state.has_usable_bitmap
LibWeb: Handle viewport scrollbar drags in the compositor Route mouse events over the compositor IPC path while async scrolling is enabled, and let the compositor capture viewport scrollbar drags before the main-thread event path sees them. Dragging mutates the compositor scroll tree and schedules an async-scroll present, so the viewport thumb and content can move without a main-thread round trip. Keep normal main-thread event handling for misses and preserve the wheel bypass behavior for page events.
2026-05-12 16:49:42 -03:00
&& mouse_event) {
if (mouse_event->type == Web::MouseEvent::Type::MouseWheel) {
auto wheel_delta_x = mouse_event->wheel_delta_x;
auto wheel_delta_y = mouse_event->wheel_delta_y;
if (mouse_event->modifiers & Web::UIEvents::KeyModifier::Mod_Shift)
swap(wheel_delta_x, wheel_delta_y);
auto device_pixels_per_css_pixel = static_cast<float>(device_pixel_ratio() * zoom_level());
auto position = Gfx::FloatPoint {
static_cast<float>(mouse_event->position.x().value()),
static_cast<float>(mouse_event->position.y().value()),
};
auto delta_in_device_pixels = Gfx::FloatPoint { wheel_delta_x, wheel_delta_y }.scaled(device_pixels_per_css_pixel);
dbgln_if(COMPOSITOR_DEBUG, "[Compositor] UI attempting compositor wheel bypass for page {} at {},{} device delta {},{}",
m_client_state.page_index, position.x(), position.y(), delta_in_device_pixels.x(), delta_in_device_pixels.y());
if (client().send_async_scroll_to_compositor(m_client_state.page_index, position, delta_in_device_pixels))
mouse_event->async_scroll_performed_default_action = true;
dbgln_if(COMPOSITOR_DEBUG, "[Compositor] UI compositor wheel bypass result for page {}: {}",
m_client_state.page_index, mouse_event->async_scroll_performed_default_action ? "accepted"sv : "rejected"sv);
LibWebView+WebContent: Add feature-gated Compositor process backend We are moving toward an architecture where the browser owns a single process that holds the GPU context, so Skia resources can be shared across every renderer and WebContent processes can be sandboxed away from direct GPU access. A dedicated Compositor helper process is the first step. The earlier commits laid the foundation; this one turns the helper on as a selectable backend, gated behind --enable-compositor-process so the existing in-process path stays the shipping default. Default topology -- one compositor per WebContent, in-process: +---------+ | Browser | +---------+ / | \ v v v +---+ +---+ +---+ each WebContent runs its own |WC | |WC | |WC | CompositorThread on a dedicated |+C+| |+C+| |+C+| thread, with its own GPU context. +---+ +---+ +---+ Opt-in topology -- one single-threaded Compositor, shared by all WCs: +---------+ control +-------------------+ | Browser |<----------->| Compositor | +---------+ | (single thread, | / | \ | single GPU ctx, | v v v data | shared by all | [WC] [WC] [WC] ---------->| connected WCs) | +-------------------+ Three IPC channels carry the work in the opt-in topology. The existing Browser<->WebContent channel gains context allocation. A new Browser<->Compositor channel carries context lifetime, viewport, UI input, and presentation acks plus backing-store and frame upcalls. A new WebContent<->Compositor channel carries display lists, scroll state, video, compositor surfaces, async scrolling, presentation, and screenshots, with upcalls for delegated input and compositor loss.
2026-05-22 11:17:27 -03:00
} else if (client().handle_mouse_event_in_compositor(m_client_state.page_index, *mouse_event)) {
LibWeb: Handle viewport scrollbar drags in the compositor Route mouse events over the compositor IPC path while async scrolling is enabled, and let the compositor capture viewport scrollbar drags before the main-thread event path sees them. Dragging mutates the compositor scroll tree and schedules an async-scroll present, so the viewport thumb and content can move without a main-thread round trip. Keep normal main-thread event handling for misses and preserve the wheel bypass behavior for page events.
2026-05-12 16:49:42 -03:00
dbgln_if(COMPOSITOR_DEBUG, "[Compositor] UI compositor handled mouse event for page {} at {},{}",
m_client_state.page_index, mouse_event->position.x().value(), mouse_event->position.y().value());
return;
}
LibWebView: Route wheel bypasses over Compositor IPC Send the experimental UI-process wheel bypass to WebContent over the Compositor IPC connection instead of adding a separate async scrolling transport. This keeps bypass admission on the channel that owns bitmaps and ready_to_paint acknowledgements. If the compositor rejects the wheel, LibWebView falls back to regular input delivery. If it accepts, mark the queued DOM event as having already performed its default action so dispatch preserves ordering without scrolling twice.
2026-05-11 16:45:34 -03:00
}
Compositor: Handle pinch zoom asynchronously Apply pinch zoom deltas to the compositor's visual viewport transform so the currently presented display list can respond without waiting for the WebContent main thread. Keep the normal WebContent pinch event path so the real VisualViewport state and DOM-visible events catch up after. Only take the compositor path when async scrolling is enabled and there are no blocking wheel listeners, since pinch zoom dispatches a synthetic wheel event that script may cancel. Coalesce queued pinch events in WebContent so main-thread catch-up can adopt multiple gesture deltas together. Use the compositor visual viewport transform for wheel hit testing and consume wheel deltas as visual viewport pan while zoomed. Scale the handoff to layout viewport scrolling by the inverse visual viewport scale, so touchpad momentum does not jump when the visual viewport hits an edge.
2026-06-14 16:30:28 -03:00
if (Application::web_content_options().enable_async_scrolling == EnableAsyncScrolling::Yes
&& m_client_state.has_usable_bitmap
&& pinch_event) {
dbgln_if(COMPOSITOR_DEBUG, "[Compositor] UI attempting compositor pinch bypass for page {} at {},{} scale delta {}",
m_client_state.page_index, pinch_event->position.x().value(), pinch_event->position.y().value(), pinch_event->scale_delta);
auto handled = client().handle_pinch_event_in_compositor(m_client_state.page_index, *pinch_event);
dbgln_if(COMPOSITOR_DEBUG, "[Compositor] UI compositor pinch bypass result for page {}: {}",
m_client_state.page_index, handled ? "accepted"sv : "rejected"sv);
}
LibWebView: Route wheel bypasses over Compositor IPC Send the experimental UI-process wheel bypass to WebContent over the Compositor IPC connection instead of adding a separate async scrolling transport. This keeps bypass admission on the channel that owns bitmaps and ready_to_paint acknowledgements. If the compositor rejects the wheel, LibWebView falls back to regular input delivery. If it accepts, mark the queued DOM event as having already performed its default action so dispatch preserves ordering without scrolling twice.
2026-05-11 16:45:34 -03:00
LibWeb+LibWebView: Migrate Browser's input event handling to LibWebView The Serenity chrome is the only chrome thus far that sends all input key and mouse events to WebContent, including shortcut activations. This is necessary for all chromes - we must give web pages a chance to intercept input events before handling them ourselves. To make this easier for other chromes, this patch moves Serenity's input event handling to LibWebView. To do so, we add the Web::InputEvent type, which models the event data we need within LibWeb. Chromes will then be responsible for converting between this type and their native events. This class lives in LibWeb (rather than LibWebView) because the plan is to use it wholesale throughout the Page's event handler and across IPC. Right now, we still send the individual fields of the event over IPC, but it will be an easy refactor to send the event itself. We just can't do this until all chromes have been ported to this event queueing. Also note that we now only handle key input events back in the chrome. WebContent handles all mouse events that it possibly can. If it was not able to handle a mouse event, there's nothing for the chrome to do (i.e. there is no clicking, scrolling, etc. the chrome is able to do if the WebContent couldn't).
2024-03-04 00:07:49 -03:00
// Send the next event over to the WebContent to be handled by JS. We'll later get a message to say whether JS
// prevented the default event behavior, at which point we either discard or handle that event, and then try to
// process the next one.
m_pending_input_events.enqueue(move(event));
m_pending_input_events.tail().visit(
[this](Web::KeyEvent const& event) {
LibWeb+UI: Rename ChromeInputData to BrowserInputData
2025-03-15 18:07:53 -03:00
client().async_key_event(m_client_state.page_index, event.clone_without_browser_data());
LibWeb+LibWebView: Migrate Browser's input event handling to LibWebView The Serenity chrome is the only chrome thus far that sends all input key and mouse events to WebContent, including shortcut activations. This is necessary for all chromes - we must give web pages a chance to intercept input events before handling them ourselves. To make this easier for other chromes, this patch moves Serenity's input event handling to LibWebView. To do so, we add the Web::InputEvent type, which models the event data we need within LibWeb. Chromes will then be responsible for converting between this type and their native events. This class lives in LibWeb (rather than LibWebView) because the plan is to use it wholesale throughout the Page's event handler and across IPC. Right now, we still send the individual fields of the event over IPC, but it will be an easy refactor to send the event itself. We just can't do this until all chromes have been ported to this event queueing. Also note that we now only handle key input events back in the chrome. WebContent handles all mouse events that it possibly can. If it was not able to handle a mouse event, there's nothing for the chrome to do (i.e. there is no clicking, scrolling, etc. the chrome is able to do if the WebContent couldn't).
2024-03-04 00:07:49 -03:00
},
[this](Web::MouseEvent const& event) {
LibWebView+WebContent: Add feature-gated Compositor process backend We are moving toward an architecture where the browser owns a single process that holds the GPU context, so Skia resources can be shared across every renderer and WebContent processes can be sandboxed away from direct GPU access. A dedicated Compositor helper process is the first step. The earlier commits laid the foundation; this one turns the helper on as a selectable backend, gated behind --enable-compositor-process so the existing in-process path stays the shipping default. Default topology -- one compositor per WebContent, in-process: +---------+ | Browser | +---------+ / | \ v v v +---+ +---+ +---+ each WebContent runs its own |WC | |WC | |WC | CompositorThread on a dedicated |+C+| |+C+| |+C+| thread, with its own GPU context. +---+ +---+ +---+ Opt-in topology -- one single-threaded Compositor, shared by all WCs: +---------+ control +-------------------+ | Browser |<----------->| Compositor | +---------+ | (single thread, | / | \ | single GPU ctx, | v v v data | shared by all | [WC] [WC] [WC] ---------->| connected WCs) | +-------------------+ Three IPC channels carry the work in the opt-in topology. The existing Browser<->WebContent channel gains context allocation. A new Browser<->Compositor channel carries context lifetime, viewport, UI input, and presentation acks plus backing-store and frame upcalls. A new WebContent<->Compositor channel carries display lists, scroll state, video, compositor surfaces, async scrolling, presentation, and screenshots, with upcalls for delegated input and compositor loss.
2026-05-22 11:17:27 -03:00
client().dispatch_mouse_event_to_web_content(m_client_state.page_index, event);
LibWeb+LibWebView+WebContent: Add IPC to send drag-and-drop events This adds the IPC and related hooks to allow the UI to send drag-and- drop events from the UI process to the WebContent process.
2024-08-17 14:36:28 -03:00
},
[this](Web::DragEvent& event) {
LibWeb+UI: Rename ChromeInputData to BrowserInputData
2025-03-15 18:07:53 -03:00
auto cloned_event = event.clone_without_browser_data();
LibWeb+LibWebView+WebContent: Add IPC to send drag-and-drop events This adds the IPC and related hooks to allow the UI to send drag-and- drop events from the UI process to the WebContent process.
2024-08-17 14:36:28 -03:00
cloned_event.files = move(event.files);
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
client().async_drag_event(m_client_state.page_index, cloned_event);
LibWeb+UI+WebContent: Pipe pinch events from AppKit UI to WebContent
2025-10-08 18:59:50 -03:00
},
[this](Web::PinchEvent const& event) {
client().async_pinch_event(m_client_state.page_index, event);
LibWeb+LibWebView: Migrate Browser's input event handling to LibWebView The Serenity chrome is the only chrome thus far that sends all input key and mouse events to WebContent, including shortcut activations. This is necessary for all chromes - we must give web pages a chance to intercept input events before handling them ourselves. To make this easier for other chromes, this patch moves Serenity's input event handling to LibWebView. To do so, we add the Web::InputEvent type, which models the event data we need within LibWeb. Chromes will then be responsible for converting between this type and their native events. This class lives in LibWeb (rather than LibWebView) because the plan is to use it wholesale throughout the Page's event handler and across IPC. Right now, we still send the individual fields of the event over IPC, but it will be an easy refactor to send the event itself. We just can't do this until all chromes have been ported to this event queueing. Also note that we now only handle key input events back in the chrome. WebContent handles all mouse events that it possibly can. If it was not able to handle a mouse event, there's nothing for the chrome to do (i.e. there is no clicking, scrolling, etc. the chrome is able to do if the WebContent couldn't).
2024-03-04 00:07:49 -03:00
});
}
LibWeb+LibWebView+WebContent: Return a named enum from UI event handlers UI event handlers currently return a boolean where false means the event was cancelled by a script on the page, or otherwise dropped. It has been a point of confusion for some time now, as it's not particularly clear what should be returned in some special cases, or how the UI process should handle the response. This adds an enumeration with a few states that indicate exactly how the WebContent process handled the event. This should remove all ambiguity, and let us properly handle these states going forward. There should be no behavior change with this patch. It's meant to only introduce the enum, not change any of our decisions based on the result.
2024-09-12 13:56:31 -03:00
void ViewImplementation::did_finish_handling_input_event(Badge<WebContentClient>, Web::EventResult event_result)
LibWeb+LibWebView: Migrate Browser's input event handling to LibWebView The Serenity chrome is the only chrome thus far that sends all input key and mouse events to WebContent, including shortcut activations. This is necessary for all chromes - we must give web pages a chance to intercept input events before handling them ourselves. To make this easier for other chromes, this patch moves Serenity's input event handling to LibWebView. To do so, we add the Web::InputEvent type, which models the event data we need within LibWeb. Chromes will then be responsible for converting between this type and their native events. This class lives in LibWeb (rather than LibWebView) because the plan is to use it wholesale throughout the Page's event handler and across IPC. Right now, we still send the individual fields of the event over IPC, but it will be an easy refactor to send the event itself. We just can't do this until all chromes have been ported to this event queueing. Also note that we now only handle key input events back in the chrome. WebContent handles all mouse events that it possibly can. If it was not able to handle a mouse event, there's nothing for the chrome to do (i.e. there is no clicking, scrolling, etc. the chrome is able to do if the WebContent couldn't).
2024-03-04 00:07:49 -03:00
{
auto event = m_pending_input_events.dequeue();
LibWeb+LibWebView+WebContent: Return a named enum from UI event handlers UI event handlers currently return a boolean where false means the event was cancelled by a script on the page, or otherwise dropped. It has been a point of confusion for some time now, as it's not particularly clear what should be returned in some special cases, or how the UI process should handle the response. This adds an enumeration with a few states that indicate exactly how the WebContent process handled the event. This should remove all ambiguity, and let us properly handle these states going forward. There should be no behavior change with this patch. It's meant to only introduce the enum, not change any of our decisions based on the result.
2024-09-12 13:56:31 -03:00
if (event_result == Web::EventResult::Handled)
LibWeb+LibWebView+WebContent: Add IPC to send drag-and-drop events This adds the IPC and related hooks to allow the UI to send drag-and- drop events from the UI process to the WebContent process.
2024-08-17 14:36:28 -03:00
return;
LibWeb+LibWebView: Migrate Browser's input event handling to LibWebView The Serenity chrome is the only chrome thus far that sends all input key and mouse events to WebContent, including shortcut activations. This is necessary for all chromes - we must give web pages a chance to intercept input events before handling them ourselves. To make this easier for other chromes, this patch moves Serenity's input event handling to LibWebView. To do so, we add the Web::InputEvent type, which models the event data we need within LibWeb. Chromes will then be responsible for converting between this type and their native events. This class lives in LibWeb (rather than LibWebView) because the plan is to use it wholesale throughout the Page's event handler and across IPC. Right now, we still send the individual fields of the event over IPC, but it will be an easy refactor to send the event itself. We just can't do this until all chromes have been ported to this event queueing. Also note that we now only handle key input events back in the chrome. WebContent handles all mouse events that it possibly can. If it was not able to handle a mouse event, there's nothing for the chrome to do (i.e. there is no clicking, scrolling, etc. the chrome is able to do if the WebContent couldn't).
2024-03-04 00:07:49 -03:00
LibWeb+LibWebView+WebContent: Add IPC to send drag-and-drop events This adds the IPC and related hooks to allow the UI to send drag-and- drop events from the UI process to the WebContent process.
2024-08-17 14:36:28 -03:00
// Here we handle events that were not consumed or cancelled by the WebContent. Propagate the event back
// to the concrete view implementation.
event.visit(
[this](Web::KeyEvent const& event) {
if (on_finish_handling_key_event)
on_finish_handling_key_event(event);
},
[this](Web::DragEvent const& event) {
if (on_finish_handling_drag_event)
on_finish_handling_drag_event(event);
},
[](auto const&) {});
LibWeb+LibWebView: Migrate Browser's input event handling to LibWebView The Serenity chrome is the only chrome thus far that sends all input key and mouse events to WebContent, including shortcut activations. This is necessary for all chromes - we must give web pages a chance to intercept input events before handling them ourselves. To make this easier for other chromes, this patch moves Serenity's input event handling to LibWebView. To do so, we add the Web::InputEvent type, which models the event data we need within LibWeb. Chromes will then be responsible for converting between this type and their native events. This class lives in LibWeb (rather than LibWebView) because the plan is to use it wholesale throughout the Page's event handler and across IPC. Right now, we still send the individual fields of the event over IPC, but it will be an easy refactor to send the event itself. We just can't do this until all chromes have been ported to this event queueing. Also note that we now only handle key input events back in the chrome. WebContent handles all mouse events that it possibly can. If it was not able to handle a mouse event, there's nothing for the chrome to do (i.e. there is no clicking, scrolling, etc. the chrome is able to do if the WebContent couldn't).
2024-03-04 00:07:49 -03:00
}
LibWebView+Ladybird: Move preferred color scheme to ViewImplementation
2023-01-12 17:44:42 -03:00
void ViewImplementation::set_preferred_color_scheme(Web::CSS::PreferredColorScheme color_scheme)
{
LibWebView: Track forced color scheme for fallback fills Remember the preferred color scheme selected through the debug menu when choosing the web view fallback background. Keep using an explicit forced scheme even if the platform theme changes underneath it.
2026-05-27 05:25:08 -03:00
m_preferred_color_scheme = color_scheme;
set_page_background_color(preferred_canvas_background_color());
LibWebView: Avoid white initial web view fills in dark mode Seed the page background fallback from the platform color scheme before WebContent has painted. Update the same fallback when the platform theme changes, and when the preferred color scheme is forced through the debug menu, so unpainted web view areas use the matching Canvas color.
2026-05-26 20:11:14 -03:00
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_set_preferred_color_scheme(page_id(), color_scheme);
LibWebView+Ladybird: Move preferred color scheme to ViewImplementation
2023-01-12 17:44:42 -03:00
}
LibWeb: Add Contrast preference
2024-06-12 20:03:56 -03:00
void ViewImplementation::set_preferred_contrast(Web::CSS::PreferredContrast contrast)
{
client().async_set_preferred_contrast(page_id(), contrast);
}
LibWeb: Add motion preference This adds a motion preference to the browser UI similar to the existing ones for color scheme and contrast. Both AppKit UI and Qt UI has this new preference. The auto value is currently the same as NoPreference, follow-ups can address wiring that up to the actual preference for the OS.
2024-06-13 11:15:59 -03:00
void ViewImplementation::set_preferred_motion(Web::CSS::PreferredMotion motion)
{
client().async_set_preferred_motion(page_id(), motion);
}
LibDevTools: Report cookie storage changes Firefox keeps the Storage table current through storesUpdate messages from the storage actor. Forward browser cookie change notifications to the cookies actor and classify visible rows against a fresh cookie snapshot. The existing cookie-change notifications report cookies that are relevant to a specific page, whereas DevTools wants all cookies relevant for a host, so we end up having to provide two different sets of cookies to `notify_cookies_changed()`.
2026-06-10 07:19:44 -03:00
void ViewImplementation::notify_cookies_changed(HashTable<String> const& changed_domains, ReadonlySpan<HTTP::Cookie::Cookie> page_cookies, ReadonlySpan<HTTP::Cookie::Cookie> host_cookies)
LibWeb+LibWebView+WebContent: Perform cookie URL filtering in the UI When cookies change or expire, we currently send a list of all changed cookies to all WebContent processes. We then filter that list in the WebContent process for cookies that match the page's URL before sending out cookie change events to JS. We now perform this filtering in the UI process, so each WebContent process only receives the cookies it would be interested in, if any. This serves two purposes: 1. Less IPC chatter. 2. This will let each ViewImplementation know that its cookie value has actually changed. (2) is for an upcoming change that will introduce a cookie cache, and will allow each view to know it should bust that cache. Note that for this filtering to work, we must iterate ViewImplementation instances rather than WebContentClient in order to have the view's URL. We must then associate the IPC with the view's page ID. No changes to the /cookiestore WPT subtests.
2026-01-30 10:52:34 -03:00
{
LibWeb+LibWebView+WebContent: Implement versioning for document cookies This patch introduces a cookie cache in the WebContent process to reduce blocking IPC calls when JS accesses document.cookie. The UI process now maintains a cookie version counter per-domain in shared memory. When JS reads document.cookie, we check whether we have a valid cached cookie by comparing the current shared version to the last used version. If they match, the cached cookie is returned without IPC. This optimization is based on Chromium's shared versioning, in which it was observed that 87% of document.cookie accesses were redundant. See: https://blog.chromium.org/2024/06/introducing-shared-memory-versioning-to.html Note that this cache only supports document.cookie, not HTTP Cookie headers. HTTP cookies are attached to requests with varying URLs and paths. The cookies that match the document URL might not match the request URL, which we wouldn't know from WebContent. So attaching the cached document cookie would be incorrect. On https://twinings.co.uk, we see approximately 600 document.cookie requests while the page loads. This patch reduces the time spent in the document.cookie getter from ~45ms to 2-3ms.
2026-02-01 15:27:19 -03:00
for (auto const& domain : changed_domains) {
if (auto document_index = m_document_cookie_version_indices.get(domain); document_index.has_value())
Core::increment_shared_version(m_document_cookie_version_buffer, *document_index);
}
LibDevTools: Report cookie storage changes Firefox keeps the Storage table current through storesUpdate messages from the storage actor. Forward browser cookie change notifications to the cookies actor and classify visible rows against a fresh cookie snapshot. The existing cookie-change notifications report cookies that are relevant to a specific page, whereas DevTools wants all cookies relevant for a host, so we end up having to provide two different sets of cookies to `notify_cookies_changed()`.
2026-06-10 07:19:44 -03:00
if (!page_cookies.is_empty())
client().async_cookies_changed(page_id(), page_cookies);
if (m_on_host_cookie_change)
m_on_host_cookie_change(Vector<HTTP::Cookie::Cookie> { host_cookies });
}
void ViewImplementation::listen_for_host_cookie_changes(DevTools::DevToolsDelegate::OnHostCookieChange on_cookie_change)
{
m_on_host_cookie_change = move(on_cookie_change);
}
void ViewImplementation::stop_listening_for_host_cookie_changes()
{
m_on_host_cookie_change = nullptr;
LibWeb+LibWebView+WebContent: Implement versioning for document cookies This patch introduces a cookie cache in the WebContent process to reduce blocking IPC calls when JS accesses document.cookie. The UI process now maintains a cookie version counter per-domain in shared memory. When JS reads document.cookie, we check whether we have a valid cached cookie by comparing the current shared version to the last used version. If they match, the cached cookie is returned without IPC. This optimization is based on Chromium's shared versioning, in which it was observed that 87% of document.cookie accesses were redundant. See: https://blog.chromium.org/2024/06/introducing-shared-memory-versioning-to.html Note that this cache only supports document.cookie, not HTTP Cookie headers. HTTP cookies are attached to requests with varying URLs and paths. The cookies that match the document URL might not match the request URL, which we wouldn't know from WebContent. So attaching the cached document cookie would be incorrect. On https://twinings.co.uk, we see approximately 600 document.cookie requests while the page loads. This patch reduces the time spent in the document.cookie getter from ~45ms to 2-3ms.
2026-02-01 15:27:19 -03:00
}
LibWeb+LibDevTools: Report Web Storage changes Firefox keeps the Storage panel current by sending store update packets when localStorage or sessionStorage changes. Forward successful Web Storage mutations to the storage actors and emit the matching update or clear packet. Use listener IDs for storage updates so the local and session storage actors can subscribe independently.
2026-06-11 10:12:37 -03:00
void ViewImplementation::notify_storage_changed(DevTools::DevToolsDelegate::StorageChange change)
{
for (auto& listener : m_storage_change_listeners)
listener.value(change);
}
u64 ViewImplementation::add_storage_change_listener(DevTools::DevToolsDelegate::OnStorageChange on_storage_change)
{
auto listener_id = m_next_storage_change_listener_id++;
m_storage_change_listeners.set(listener_id, move(on_storage_change));
return listener_id;
}
void ViewImplementation::remove_storage_change_listener(u64 listener_id)
{
m_storage_change_listeners.remove(listener_id);
}
LibWeb+LibWebView+WebContent: Implement versioning for document cookies This patch introduces a cookie cache in the WebContent process to reduce blocking IPC calls when JS accesses document.cookie. The UI process now maintains a cookie version counter per-domain in shared memory. When JS reads document.cookie, we check whether we have a valid cached cookie by comparing the current shared version to the last used version. If they match, the cached cookie is returned without IPC. This optimization is based on Chromium's shared versioning, in which it was observed that 87% of document.cookie accesses were redundant. See: https://blog.chromium.org/2024/06/introducing-shared-memory-versioning-to.html Note that this cache only supports document.cookie, not HTTP Cookie headers. HTTP cookies are attached to requests with varying URLs and paths. The cookies that match the document URL might not match the request URL, which we wouldn't know from WebContent. So attaching the cached document cookie would be incorrect. On https://twinings.co.uk, we see approximately 600 document.cookie requests while the page loads. This patch reduces the time spent in the document.cookie getter from ~45ms to 2-3ms.
2026-02-01 15:27:19 -03:00
ErrorOr<Core::SharedVersionIndex> ViewImplementation::ensure_document_cookie_version_index(Badge<WebContentClient>, String const& domain)
{
return m_document_cookie_version_indices.try_ensure(domain, [&]() -> ErrorOr<Core::SharedVersionIndex> {
Core::SharedVersionIndex document_index = m_document_cookie_version_indices.size();
if (!Core::initialize_shared_version(m_document_cookie_version_buffer, document_index)) {
dbgln("Reached maximum document cookie version count for {}, cannot create new version for {}", m_url, domain);
return Error::from_string_literal("Reached maximum document cookie version count");
}
return document_index;
});
}
Optional<Core::SharedVersion> ViewImplementation::document_cookie_version(URL::URL const& url) const
{
LibHTTP+Everywhere: Move the cookie implementation to LibHTTP This will allow parsing cookies outside of LibWeb. LibHTTP is basically becoming the home of HTTP WG specs.
2026-02-07 13:13:47 -03:00
auto domain = HTTP::Cookie::canonicalize_domain(url);
LibWeb+LibWebView+WebContent: Implement versioning for document cookies This patch introduces a cookie cache in the WebContent process to reduce blocking IPC calls when JS accesses document.cookie. The UI process now maintains a cookie version counter per-domain in shared memory. When JS reads document.cookie, we check whether we have a valid cached cookie by comparing the current shared version to the last used version. If they match, the cached cookie is returned without IPC. This optimization is based on Chromium's shared versioning, in which it was observed that 87% of document.cookie accesses were redundant. See: https://blog.chromium.org/2024/06/introducing-shared-memory-versioning-to.html Note that this cache only supports document.cookie, not HTTP Cookie headers. HTTP cookies are attached to requests with varying URLs and paths. The cookies that match the document URL might not match the request URL, which we wouldn't know from WebContent. So attaching the cached document cookie would be incorrect. On https://twinings.co.uk, we see approximately 600 document.cookie requests while the page loads. This patch reduces the time spent in the document.cookie getter from ~45ms to 2-3ms.
2026-02-01 15:27:19 -03:00
if (!domain.has_value())
return {};
auto document_index = m_document_cookie_version_indices.get(*domain);
if (!document_index.has_value())
return {};
return Core::get_shared_version(m_document_cookie_version_buffer, *document_index);
LibWeb+LibWebView+WebContent: Perform cookie URL filtering in the UI When cookies change or expire, we currently send a list of all changed cookies to all WebContent processes. We then filter that list in the WebContent process for cookies that match the page's URL before sending out cookie change events to JS. We now perform this filtering in the UI process, so each WebContent process only receives the cookies it would be interested in, if any. This serves two purposes: 1. Less IPC chatter. 2. This will let each ViewImplementation know that its cookie value has actually changed. (2) is for an upcoming change that will introduce a cookie cache, and will allow each view to know it should bust that cache. Note that for this filtering to work, we must iterate ViewImplementation instances rather than WebContentClient in order to have the view's URL. We must then associate the IPC with the view's page ID. No changes to the /cookiestore WPT subtests.
2026-01-30 10:52:34 -03:00
}
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 11:19:34 -03:00
ByteString ViewImplementation::selected_text()
LibWebView+Ladybird: Move text selection to ViewImplementation
2023-01-12 17:42:42 -03:00
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
return client().get_selected_text(page_id());
LibWebView+Ladybird: Move text selection to ViewImplementation
2023-01-12 17:42:42 -03:00
}
LibWeb+LibWebView+WebContent+UI: Add an action to cut text
2026-05-06 13:00:59 -03:00
ByteString ViewImplementation::cut_selected_text()
{
return client().cut_selected_text(page_id());
}
LibWebView: Add a helper to get selected text with collapsed whitespace
2023-10-23 17:52:57 -03:00
Optional<String> ViewImplementation::selected_text_with_whitespace_collapsed()
{
auto selected_text = MUST(Web::Infra::strip_and_collapse_whitespace(this->selected_text()));
if (selected_text.is_empty())
return OptionalNone {};
return selected_text;
}
LibWebView+Ladybird: Move text selection to ViewImplementation
2023-01-12 17:42:42 -03:00
void ViewImplementation::select_all()
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_select_all(page_id());
LibWebView+Ladybird: Move text selection to ViewImplementation
2023-01-12 17:42:42 -03:00
}
LibWeb+LibWebView+WebContent: Support case-insensitive find-in-page This allows searching for text with case-insensitivity. As this is probably what most users expect, the default behavior is changes to perform case-insensitive lookups. Chromes may add UI to change the behavior as they see fit.
2024-05-31 17:01:34 -03:00
void ViewImplementation::find_in_page(String const& query, CaseSensitivity case_sensitivity)
LibWeb+LibWebView+WebContent: Add basic find in page functionality This allows the browser to send a query to the WebContent process, which will search the page for the given string and highlight any occurrences of that string.
2024-05-29 16:09:33 -03:00
{
LibWeb+LibWebView+WebContent: Support case-insensitive find-in-page This allows searching for text with case-insensitivity. As this is probably what most users expect, the default behavior is changes to perform case-insensitive lookups. Chromes may add UI to change the behavior as they see fit.
2024-05-31 17:01:34 -03:00
client().async_find_in_page(page_id(), query, case_sensitivity);
LibWeb+LibWebView+WebContent: Add basic find in page functionality This allows the browser to send a query to the WebContent process, which will search the page for the given string and highlight any occurrences of that string.
2024-05-29 16:09:33 -03:00
}
void ViewImplementation::find_in_page_next_match()
{
client().async_find_in_page_next_match(page_id());
}
void ViewImplementation::find_in_page_previous_match()
{
client().async_find_in_page_previous_match(page_id());
}
LibWebView+Ladybird: Move get source request to ViewImplementation
2023-01-12 16:58:00 -03:00
void ViewImplementation::get_source()
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_get_source(page_id());
LibWebView+Ladybird: Move get source request to ViewImplementation
2023-01-12 16:58:00 -03:00
}
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
void ViewImplementation::inspect_dom_tree()
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_inspect_dom_tree(page_id());
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
}
LibDevTools: Populate DevTools Web Storage Firefox exposes localStorage and sessionStorage through the same storage actor protocol used by cookies. Add matching resources for the current tab so the Storage panel can list key/value pairs. Read the values through WebContent rather than directly from the browser process. Session storage lives in LibWeb, and using the same path for both stores keeps the actor independent of the backing store.
2026-06-10 12:15:21 -03:00
void ViewImplementation::inspect_storage(Web::StorageAPI::StorageEndpointType storage_endpoint, u64 request_id)
{
client().async_inspect_storage(page_id(), storage_endpoint, request_id);
}
LibDevTools: Allow editing Web Storage Firefox sends the same storage actor mutation requests for Web Storage that it uses for cookies. Handle addItem, editItem, removeItem, and removeAll for localStorage and sessionStorage actors. Apply the changes through the browser-process storage jar and emit the matching store update packets so the Storage panel stays current after a DevTools-initiated edit.
2026-06-10 12:27:25 -03:00
Optional<StorageSetResult> ViewImplementation::set_session_storage_item(String const& key, String const& value)
{
return client().set_session_storage_item(page_id(), key, value);
}
Optional<String> ViewImplementation::remove_session_storage_item(String const& key)
{
return client().remove_session_storage_item(page_id(), key);
}
bool ViewImplementation::clear_session_storage()
{
return client().clear_session_storage(page_id());
}
LibWeb+LibWebView+WebContent: Support both inspecting/highlighting nodes Our own Inspector differs from most other DevTools implementations with regard to highlighting DOM nodes as you hover elements in the inspected DOM tree. In other implementations, as you change the hovered node, the browser will render a box model overlay onto the page for that node. We currently don't do this; we wait until you click the node, at which point we both paint the overlay and inspect the node's properties. This patch does not change that behavior, but separates the IPCs and internal tracking of inspected nodes to support the standard DevTools behavior. So the DOM document now stores an inspected node and a highlighted node. The former is used for features such as "$0" in the JavaScript console, and the latter is used for the box model overlay. Our Inspector continues to set these to the same node.
2025-02-21 11:34:02 -03:00
void ViewImplementation::inspect_accessibility_tree()
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
{
LibWeb+LibWebView+WebContent: Support both inspecting/highlighting nodes Our own Inspector differs from most other DevTools implementations with regard to highlighting DOM nodes as you hover elements in the inspected DOM tree. In other implementations, as you change the hovered node, the browser will render a box model overlay onto the page for that node. We currently don't do this; we wait until you click the node, at which point we both paint the overlay and inspect the node's properties. This patch does not change that behavior, but separates the IPCs and internal tracking of inspected nodes to support the standard DevTools behavior. So the DOM document now stores an inspected node and a highlighted node. The former is used for features such as "$0" in the JavaScript console, and the latter is used for the box model overlay. Our Inspector continues to set these to the same node.
2025-02-21 11:34:02 -03:00
client().async_inspect_accessibility_tree(page_id());
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
}
LibWeb+LibWebView+WebContent: Support both inspecting/highlighting nodes Our own Inspector differs from most other DevTools implementations with regard to highlighting DOM nodes as you hover elements in the inspected DOM tree. In other implementations, as you change the hovered node, the browser will render a box model overlay onto the page for that node. We currently don't do this; we wait until you click the node, at which point we both paint the overlay and inspect the node's properties. This patch does not change that behavior, but separates the IPCs and internal tracking of inspected nodes to support the standard DevTools behavior. So the DOM document now stores an inspected node and a highlighted node. The former is used for features such as "$0" in the JavaScript console, and the latter is used for the box model overlay. Our Inspector continues to set these to the same node.
2025-02-21 11:34:02 -03:00
void ViewImplementation::get_hovered_node_id()
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
{
LibWeb+LibWebView+WebContent: Support both inspecting/highlighting nodes Our own Inspector differs from most other DevTools implementations with regard to highlighting DOM nodes as you hover elements in the inspected DOM tree. In other implementations, as you change the hovered node, the browser will render a box model overlay onto the page for that node. We currently don't do this; we wait until you click the node, at which point we both paint the overlay and inspect the node's properties. This patch does not change that behavior, but separates the IPCs and internal tracking of inspected nodes to support the standard DevTools behavior. So the DOM document now stores an inspected node and a highlighted node. The former is used for features such as "$0" in the JavaScript console, and the latter is used for the box model overlay. Our Inspector continues to set these to the same node.
2025-02-21 11:34:02 -03:00
client().async_get_hovered_node_id(page_id());
}
LibWebView: Wire node picker state to hit testing LibWebView owns the active page connection and bridges the DevTools delegate to WebContent. Track picker state there, translate UI hover, preview, pick, and cancel requests into hit-test IPC, and forward the resulting node ids back through the DevTools callback. Keeping the request bookkeeping in LibWebView also lets the platform UI frontends share the same picker behavior.
2026-05-28 08:14:41 -03:00
void ViewImplementation::start_node_picker(DevTools::DevToolsDelegate::OnNodePickerEvent on_node_picker_event)
{
m_node_picker_active = true;
m_node_picker_hovered_node_id.clear();
m_pending_node_picker_requests.clear();
m_on_node_picker_event = move(on_node_picker_event);
}
void ViewImplementation::stop_node_picker()
{
if (!m_node_picker_active)
return;
clear_node_picker();
m_node_picker_active = false;
m_pending_node_picker_requests.clear();
m_on_node_picker_event = nullptr;
}
void ViewImplementation::clear_node_picker()
{
m_node_picker_hovered_node_id.clear();
clear_highlighted_dom_node();
}
void ViewImplementation::node_picker_hover(Web::DevicePixelPoint position)
{
request_node_picker_hit_test(NodePickerRequestType::Hovered, position);
}
void ViewImplementation::node_picker_pick(Web::DevicePixelPoint position)
{
request_node_picker_hit_test(NodePickerRequestType::Picked, position);
}
void ViewImplementation::node_picker_preview(Web::DevicePixelPoint position)
{
request_node_picker_hit_test(NodePickerRequestType::Previewed, position);
}
void ViewImplementation::node_picker_cancel()
{
if (!m_node_picker_active)
return;
if (m_on_node_picker_event) {
m_on_node_picker_event({
.type = DevTools::DevToolsDelegate::NodePickerEvent::Type::Canceled,
.node_id = {},
});
}
}
void ViewImplementation::request_node_picker_hit_test(NodePickerRequestType type, Web::DevicePixelPoint position)
{
if (!m_node_picker_active)
return;
auto request_id = m_next_node_picker_request_id++;
m_pending_node_picker_requests.set(request_id, type);
client().async_get_node_id_at_position(page_id(), request_id, position);
}
void ViewImplementation::did_receive_node_picker_hit_test(u64 request_id, Web::UniqueNodeID node_id)
{
auto request_type = m_pending_node_picker_requests.take(request_id);
if (!request_type.has_value() || !m_node_picker_active)
return;
if (*request_type == NodePickerRequestType::Hovered) {
if (node_id == m_node_picker_hovered_node_id.value_or(0))
return;
m_node_picker_hovered_node_id = node_id;
if (node_id == 0) {
clear_node_picker();
return;
}
} else if (node_id == 0) {
return;
}
if (!m_on_node_picker_event)
return;
DevTools::DevToolsDelegate::NodePickerEvent::Type event_type;
switch (*request_type) {
case NodePickerRequestType::Hovered:
event_type = DevTools::DevToolsDelegate::NodePickerEvent::Type::Hovered;
break;
case NodePickerRequestType::Picked:
event_type = DevTools::DevToolsDelegate::NodePickerEvent::Type::Picked;
break;
case NodePickerRequestType::Previewed:
event_type = DevTools::DevToolsDelegate::NodePickerEvent::Type::Previewed;
break;
}
m_on_node_picker_event({
.type = event_type,
.node_id = node_id,
});
}
LibWebView+WebContent: Pass DOM inspection options Extend the existing DOM node inspection request with an options payload and carry it through the browser process, WebView, IPC, and WebContent. This lets later DevTools requests forward Firefox's top-level flags without changing any inspected-node behavior yet.
2026-06-04 11:17:17 -03:00
void ViewImplementation::inspect_dom_node(Web::UniqueNodeID node_id, DOMNodeProperties::Type property_type, Optional<Web::CSS::PseudoElement> pseudo_element, JsonValue options)
LibWeb+LibWebView+WebContent: Support both inspecting/highlighting nodes Our own Inspector differs from most other DevTools implementations with regard to highlighting DOM nodes as you hover elements in the inspected DOM tree. In other implementations, as you change the hovered node, the browser will render a box model overlay onto the page for that node. We currently don't do this; we wait until you click the node, at which point we both paint the overlay and inspect the node's properties. This patch does not change that behavior, but separates the IPCs and internal tracking of inspected nodes to support the standard DevTools behavior. So the DOM document now stores an inspected node and a highlighted node. The former is used for features such as "$0" in the JavaScript console, and the latter is used for the box model overlay. Our Inspector continues to set these to the same node.
2025-02-21 11:34:02 -03:00
{
LibWebView+WebContent: Pass DOM inspection options Extend the existing DOM node inspection request with an options payload and carry it through the browser process, WebView, IPC, and WebContent. This lets later DevTools requests forward Firefox's top-level flags without changing any inspected-node behavior yet.
2026-06-04 11:17:17 -03:00
client().async_inspect_dom_node(page_id(), property_type, node_id, pseudo_element, move(options));
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
}
DevTools: Add grid layout WebContent plumbing Add IPC structures and requests for inspecting grid layout data from WebContent. WebView forwards the async replies to LibDevTools and exposes the grid highlighter hooks used by the protocol layer. Parse Firefox grid highlighter options in WebContent and store them with the active grid highlight.
2026-05-22 10:42:29 -03:00
void ViewImplementation::inspect_grid_layouts(Web::UniqueNodeID root_node_id)
{
client().async_inspect_grid_layouts(page_id(), root_node_id);
}
void ViewImplementation::inspect_current_grid(Web::UniqueNodeID node_id)
{
client().async_inspect_current_grid(page_id(), node_id);
}
WebContent+LibWebView: Add flexbox inspection plumbing
2026-05-27 12:41:13 -03:00
void ViewImplementation::inspect_current_flexbox(Web::UniqueNodeID node_id, bool only_look_at_parents)
{
client().async_inspect_current_flexbox(page_id(), node_id, only_look_at_parents);
}
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
void ViewImplementation::clear_inspected_dom_node()
{
LibDevTools+LibWebView+WebContent: Selectively fetch DOM node properties When we inspect a DOM node, we currently serialize many properties for that node, including its layout, computed style, used fonts, etc. Now that we aren't piggy-backing on the Inspector interface, we can instead only serialize the specific information required by DevTools.
2025-03-19 16:50:56 -03:00
client().async_clear_inspected_dom_node(page_id());
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
}
LibWeb/CSS: Move and rename PseudoElement types to prep for code gen The upcoming generated types will match those for pseudo-classes: A PseudoElementSelector type, that then holds a PseudoElement enum defining what it is. That enum will be at the top level in the Web::CSS namespace. In order to keep the diffs clearer, this commit renames and moves the types, and then a following one will replace the handwritten enum with a generated one.
2025-03-20 13:56:46 -03:00
void ViewImplementation::highlight_dom_node(Web::UniqueNodeID node_id, Optional<Web::CSS::PseudoElement> pseudo_element)
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
{
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
client().async_highlight_dom_node(page_id(), node_id, pseudo_element);
LibWeb+LibWebView+WebContent: Support both inspecting/highlighting nodes Our own Inspector differs from most other DevTools implementations with regard to highlighting DOM nodes as you hover elements in the inspected DOM tree. In other implementations, as you change the hovered node, the browser will render a box model overlay onto the page for that node. We currently don't do this; we wait until you click the node, at which point we both paint the overlay and inspect the node's properties. This patch does not change that behavior, but separates the IPCs and internal tracking of inspected nodes to support the standard DevTools behavior. So the DOM document now stores an inspected node and a highlighted node. The former is used for features such as "$0" in the JavaScript console, and the latter is used for the box model overlay. Our Inspector continues to set these to the same node.
2025-02-21 11:34:02 -03:00
}
void ViewImplementation::clear_highlighted_dom_node()
{
highlight_dom_node(0, {});
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
}
DevTools+WebContent: Support the flexbox highlighter
2026-05-27 13:12:14 -03:00
void ViewImplementation::highlight_flexbox(Web::UniqueNodeID node_id, JsonValue options)
{
client().async_highlight_flexbox(page_id(), node_id, move(options));
}
void ViewImplementation::clear_flexbox_highlight(Web::UniqueNodeID node_id)
{
client().async_clear_flexbox_highlight(page_id(), node_id);
}
DevTools: Add grid layout WebContent plumbing Add IPC structures and requests for inspecting grid layout data from WebContent. WebView forwards the async replies to LibDevTools and exposes the grid highlighter hooks used by the protocol layer. Parse Firefox grid highlighter options in WebContent and store them with the active grid highlight.
2026-05-22 10:42:29 -03:00
void ViewImplementation::highlight_grid(Web::UniqueNodeID node_id, JsonValue options)
{
client().async_highlight_grid(page_id(), node_id, move(options));
}
void ViewImplementation::clear_grid_highlight(Web::UniqueNodeID node_id)
{
client().async_clear_grid_highlight(page_id(), node_id);
}
LibWeb+LibWebView+WebContent: Inform the UI about DOM mutations This will allow our DevTools server to inform the Firefox DevTools client about DOM mutations.
2025-03-06 19:32:43 -03:00
void ViewImplementation::set_listen_for_dom_mutations(bool listen_for_dom_mutations)
{
client().async_set_listen_for_dom_mutations(page_id(), listen_for_dom_mutations);
}
LibDevTools: Only send network response bodies when DevTools connected To avoid unnecessary IPC traffic, we now only send network response bodies when a DevTools client is connected. This requires tracking DevTools connection state in ViewImplementation so we can propagate it to new WebContent processes created during cross-site navigation.
2026-01-15 10:28:42 -03:00
void ViewImplementation::did_connect_devtools_client()
{
m_devtools_connected = true;
client().async_did_connect_devtools_client(page_id());
}
void ViewImplementation::did_disconnect_devtools_client()
{
m_devtools_connected = false;
client().async_did_disconnect_devtools_client(page_id());
}
LibDevTools+LibWebView+WebContent: Implement getting DOM node inner HTML This is used by DevTools to copy the inner HTML to the clipboard.
2025-03-10 19:15:31 -03:00
void ViewImplementation::get_dom_node_inner_html(Web::UniqueNodeID node_id)
{
client().async_get_dom_node_inner_html(page_id(), node_id);
}
LibDevTools+LibWebView+WebContent: Implement editing DOM node HTML These commands are used for the "Edit As HTML" feature in DevTools. This renames our existing HTML getter IPC to indicate that it is for outer HTML. DevTools will need a separate inner HTML getter.
2025-03-10 18:36:41 -03:00
void ViewImplementation::get_dom_node_outer_html(Web::UniqueNodeID node_id)
{
client().async_get_dom_node_outer_html(page_id(), node_id);
}
void ViewImplementation::set_dom_node_outer_html(Web::UniqueNodeID node_id, String const& html)
{
client().async_set_dom_node_outer_html(page_id(), node_id, html);
}
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
void ViewImplementation::set_dom_node_text(Web::UniqueNodeID node_id, String const& text)
LibWebView+WebContent: Add APIs to manipulate DOM nodes This adds APIs to allow Ispector clients to: * Change a DOM text or comment node's text data. * Add, replace, or remove a DOM element's attribute. * Change a DOM element's tag.
2023-11-19 12:42:11 -03:00
{
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
client().async_set_dom_node_text(page_id(), node_id, text);
LibWebView+WebContent: Add APIs to manipulate DOM nodes This adds APIs to allow Ispector clients to: * Change a DOM text or comment node's text data. * Add, replace, or remove a DOM element's attribute. * Change a DOM element's tag.
2023-11-19 12:42:11 -03:00
}
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
void ViewImplementation::set_dom_node_tag(Web::UniqueNodeID node_id, String const& name)
LibWebView+WebContent: Add APIs to manipulate DOM nodes This adds APIs to allow Ispector clients to: * Change a DOM text or comment node's text data. * Add, replace, or remove a DOM element's attribute. * Change a DOM element's tag.
2023-11-19 12:42:11 -03:00
{
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
client().async_set_dom_node_tag(page_id(), node_id, name);
LibWebView+WebContent: Add APIs to manipulate DOM nodes This adds APIs to allow Ispector clients to: * Change a DOM text or comment node's text data. * Add, replace, or remove a DOM element's attribute. * Change a DOM element's tag.
2023-11-19 12:42:11 -03:00
}
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
void ViewImplementation::add_dom_node_attributes(Web::UniqueNodeID node_id, ReadonlySpan<Attribute> attributes)
LibWebView+WebContent: Add a WebContent IPC to add DOM attributes
2023-12-05 18:49:47 -03:00
{
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
client().async_add_dom_node_attributes(page_id(), node_id, attributes);
LibWebView+WebContent: Add a WebContent IPC to add DOM attributes
2023-12-05 18:49:47 -03:00
}
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
void ViewImplementation::replace_dom_node_attribute(Web::UniqueNodeID node_id, String const& name, ReadonlySpan<Attribute> replacement_attributes)
LibWebView+WebContent: Add APIs to manipulate DOM nodes This adds APIs to allow Ispector clients to: * Change a DOM text or comment node's text data. * Add, replace, or remove a DOM element's attribute. * Change a DOM element's tag.
2023-11-19 12:42:11 -03:00
{
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
client().async_replace_dom_node_attribute(page_id(), node_id, name, replacement_attributes);
LibWebView+WebContent: Add APIs to manipulate DOM nodes This adds APIs to allow Ispector clients to: * Change a DOM text or comment node's text data. * Add, replace, or remove a DOM element's attribute. * Change a DOM element's tag.
2023-11-19 12:42:11 -03:00
}
LibWeb: Make DOM Node unique IDs strongly typed (and 64 bit) This is strictly nicer than passing them around as i32 everywhere, and by switching to i64 as the underlying type, ID allocation becomes as simple as incrementing an integer.
2024-10-20 05:37:44 -03:00
void ViewImplementation::create_child_element(Web::UniqueNodeID node_id)
LibWebView+WebContent: Add WebContent IPC to create children DOM nodes This adds IPC to create append a child <div> element or a text node to a DOM node.
2023-12-07 13:00:57 -03:00
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_create_child_element(page_id(), node_id);
LibWebView+WebContent: Add WebContent IPC to create children DOM nodes This adds IPC to create append a child <div> element or a text node to a DOM node.
2023-12-07 13:00:57 -03:00
}
LibWeb: Make DOM Node unique IDs strongly typed (and 64 bit) This is strictly nicer than passing them around as i32 everywhere, and by switching to i64 as the underlying type, ID allocation becomes as simple as incrementing an integer.
2024-10-20 05:37:44 -03:00
void ViewImplementation::create_child_text_node(Web::UniqueNodeID node_id)
LibWebView+WebContent: Add WebContent IPC to create children DOM nodes This adds IPC to create append a child <div> element or a text node to a DOM node.
2023-12-07 13:00:57 -03:00
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_create_child_text_node(page_id(), node_id);
LibWebView+WebContent: Add WebContent IPC to create children DOM nodes This adds IPC to create append a child <div> element or a text node to a DOM node.
2023-12-07 13:00:57 -03:00
}
LibDevTools+LibWebView+WebContent: Implement moving DOM nodes This allows for click-and-dragging DOM nodes in DevTools to move them.
2025-03-10 19:01:29 -03:00
void ViewImplementation::insert_dom_node_before(Web::UniqueNodeID node_id, Web::UniqueNodeID parent_node_id, Optional<Web::UniqueNodeID> sibling_node_id)
{
client().async_insert_dom_node_before(page_id(), node_id, parent_node_id, sibling_node_id);
}
LibWeb: Make DOM Node unique IDs strongly typed (and 64 bit) This is strictly nicer than passing them around as i32 everywhere, and by switching to i64 as the underlying type, ID allocation becomes as simple as incrementing an integer.
2024-10-20 05:37:44 -03:00
void ViewImplementation::clone_dom_node(Web::UniqueNodeID node_id)
LibWebView+WebContent: Add a WebContent IPC to clone a DOM node
2023-12-07 13:12:43 -03:00
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_clone_dom_node(page_id(), node_id);
LibWebView+WebContent: Add a WebContent IPC to clone a DOM node
2023-12-07 13:12:43 -03:00
}
LibWeb: Make DOM Node unique IDs strongly typed (and 64 bit) This is strictly nicer than passing them around as i32 everywhere, and by switching to i64 as the underlying type, ID allocation becomes as simple as incrementing an integer.
2024-10-20 05:37:44 -03:00
void ViewImplementation::remove_dom_node(Web::UniqueNodeID node_id)
LibWebView+WebContent: Add a WebContent IPC to remove a DOM node The FIXME added to ConnectionFromClient::remove_dom_node is copied from Web::EditEventHandler. The same behavior is observed here, with many lingering Layout::TextNodes, for example.
2023-12-05 16:59:54 -03:00
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_remove_dom_node(page_id(), node_id);
LibWebView+WebContent: Add a WebContent IPC to remove a DOM node The FIXME added to ConnectionFromClient::remove_dom_node is copied from Web::EditEventHandler. The same behavior is observed here, with many lingering Layout::TextNodes, for example.
2023-12-05 16:59:54 -03:00
}
Inspector: Add a basic style sheet inspector Choosing options from the `<select>` will load and display that style sheet's source text, with some checks to make sure that the text that just loaded is the one we currently want. The UI is a little goofy when scrolling, as it uses `position: sticky` which we don't implement yet. But that's just more motivation to implement it! :^)
2024-08-23 07:18:35 -03:00
void ViewImplementation::list_style_sheets()
{
client().async_list_style_sheets(page_id());
}
void ViewImplementation::request_style_sheet_source(Web::CSS::StyleSheetIdentifier const& identifier)
{
client().async_request_style_sheet_source(page_id(), identifier);
}
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 11:19:34 -03:00
void ViewImplementation::debug_request(ByteString const& request, ByteString const& argument)
LibWebView+Ladybird: Move debug request to ViewImplementation
2023-01-12 17:34:08 -03:00
{
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
if (request == "dump-session-history"sv)
dump_session_history("debug-request"sv, SessionHistoryDumpMode::Always);
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_debug_request(page_id(), request, argument);
LibWebView+Ladybird: Move debug request to ViewImplementation
2023-01-12 17:34:08 -03:00
}
LibWebView: Share content blocker lists as buffers Add a repeatable blocker-list option that reads local list files in the browser process. The files are concatenated into one buffer and shared with WebContent through the content blocker IPC path when view options are applied. Parse the buffer in WebContent and reject malformed UTF-8 without replacing the currently installed rules.
2026-05-21 12:46:17 -03:00
void ViewImplementation::set_content_blockers(Core::AnonymousBuffer const& patterns)
{
client().async_set_content_blockers(page_id(), patterns);
}
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
void ViewImplementation::run_javascript(String const& js_source)
LibWebView+Ladybird: Move running JavaScript to ViewImplementation
2023-01-12 17:39:08 -03:00
{
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
client().async_run_javascript(page_id(), js_source);
LibWebView+Ladybird: Move running JavaScript to ViewImplementation
2023-01-12 17:39:08 -03:00
}
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
void ViewImplementation::js_console_input(String const& js_source)
Ladybird: Move ownership of the JS console/inspector to the tab object This is to match Browser, where ownership of all "subwidgets" is placed on the tab as well. This further lets us align the web view callbacks to match Browser's OOPWV as well, which will later let us move them into the base LibWebView class.
2023-05-17 12:54:36 -03:00
{
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
client().async_js_console_input(page_id(), js_source);
Ladybird: Move ownership of the JS console/inspector to the tab object This is to match Browser, where ownership of all "subwidgets" is placed on the tab as well. This further lets us align the web view callbacks to match Browser's OOPWV as well, which will later let us move them into the base LibWebView class.
2023-05-17 12:54:36 -03:00
}
LibWeb: Implement exitFullscreen algorithm Exiting fullscreen from the UI will be added in future commits.
2025-04-01 09:23:04 -03:00
void ViewImplementation::exit_fullscreen()
{
client().async_exit_fullscreen(page_id());
}
Everywhere: Add an is_fullscreen parameter to set_viewport This will be used by the UIs to notify WebContent when fullscreen for content is entered or exited.
2026-03-16 21:28:02 -03:00
void ViewImplementation::set_is_fullscreen(Web::ViewportIsFullscreen is_fullscreen)
{
if (m_is_fullscreen == is_fullscreen)
return;
LibWebView: Actually set the fullscreen flag when entering fullscreen Somehow this disappeared from #8461.
2026-03-20 20:46:50 -03:00
m_is_fullscreen = is_fullscreen;
Everywhere: Add an is_fullscreen parameter to set_viewport This will be used by the UIs to notify WebContent when fullscreen for content is entered or exited.
2026-03-16 21:28:02 -03:00
handle_resize();
did_update_window_rect();
}
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 15:23:34 -03:00
void ViewImplementation::alert_closed()
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_alert_closed(page_id());
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 15:23:34 -03:00
}
void ViewImplementation::confirm_closed(bool accepted)
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_confirm_closed(page_id(), accepted);
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 15:23:34 -03:00
}
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
void ViewImplementation::prompt_closed(Optional<String> const& response)
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 15:23:34 -03:00
{
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
client().async_prompt_closed(page_id(), response);
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 15:23:34 -03:00
}
LibWeb: Allow input color to give continuous updates
2023-12-11 02:53:10 -03:00
void ViewImplementation::color_picker_update(Optional<Color> picked_color, Web::HTML::ColorPickerUpdateState state)
LibWeb+LibWebView+WebContent: Add support for <input type="color"> This commit introduces 3 things: - Support for the color type in HTMLInputElement itself - A mechanism for handling non event loop blocking dialogs in Page - The associated plumbing up to ViewImplementation Frontends may add support for the color picker with the ViewImplementation.on_request_color_picker function
2023-09-04 06:32:40 -03:00
{
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_color_picker_update(page_id(), picked_color, state);
LibWeb+LibWebView+WebContent: Add support for <input type="color"> This commit introduces 3 things: - Support for the color type in HTMLInputElement itself - A mechanism for handling non event loop blocking dialogs in Page - The associated plumbing up to ViewImplementation Frontends may add support for the color picker with the ViewImplementation.on_request_color_picker function
2023-09-04 06:32:40 -03:00
}
LibWeb+LibWebView+WebContent: Implement more <input type=file> behavior We had previous implemented some plumbing for file input elements in commit 636602a54e55945f7394805975a69dc40934331c. This implements the return path for chromes to inform WebContent of the file(s) the user selected. This patch includes a dummy implementation for headless-browser to enable testing.
2024-02-25 15:02:47 -03:00
void ViewImplementation::file_picker_closed(Vector<Web::HTML::SelectedFile> selected_files)
{
client().async_file_picker_closed(page_id(), move(selected_files));
}
LibWeb: Refactor SelectItem to allow selecting options without value Currently the `<select>` dropdown IPC uses the option value attr to find which option is selected. This won't work when options don't have values or when multiple options have the same value. Also the `SelectItem` contained so weird recursive structures that are impossible to create with HTML. So I refactored `SelectItem` as a variant, and gave the options a unique id. The id is send back to `HTMLSelectElement` so it can find out exactly which option element is selected.
2024-04-03 14:19:08 -03:00
void ViewImplementation::select_dropdown_closed(Optional<u32> const& selected_item_id)
Ladybird+LibWeb: Add basic select element support
2023-12-07 11:53:49 -03:00
{
LibWeb: Refactor SelectItem to allow selecting options without value Currently the `<select>` dropdown IPC uses the option value attr to find which option is selected. This won't work when options don't have values or when multiple options have the same value. Also the `SelectItem` contained so weird recursive structures that are impossible to create with HTML. So I refactored `SelectItem` as a variant, and gave the options a unique id. The id is send back to `HTMLSelectElement` so it can find out exactly which option element is selected.
2024-04-03 14:19:08 -03:00
client().async_select_dropdown_closed(page_id(), selected_item_id);
Ladybird+LibWeb: Add basic select element support
2023-12-07 11:53:49 -03:00
}
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
void ViewImplementation::paste_text_from_clipboard()
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 12:29:54 -03:00
{
LibWebView+UI: Move clipboard handling from the WebView to the App Clipboard handling largely has nothing to do with the individual web views. Rather, we interact with the system clipboard at the application level. So let's move these implementations to the Application.
2025-09-18 09:16:36 -03:00
client().async_paste(page_id(), Application::the().clipboard_text());
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 12:29:54 -03:00
}
LibWeb+UI/AppKit: Implement macOS IME support This makes macOS IME input in web content work as expected. Fixes https://github.com/LadybirdBrowser/ladybird/issues/9712
2026-05-28 11:48:50 -03:00
void ViewImplementation::set_marked_text_from_input_method(Utf16String const& text)
{
client().async_set_marked_text_from_input_method(page_id(), text);
}
void ViewImplementation::commit_text_from_input_method(Utf16String const& text)
{
client().async_commit_text_from_input_method(page_id(), text);
}
void ViewImplementation::unmark_text_from_input_method()
{
client().async_unmark_text_from_input_method(page_id());
}
Optional<Web::DevicePixelRect> ViewImplementation::get_input_caret_rect()
{
// Returns the most-recent caret position pushed by WebContent (see set_input_caret_rect). Deliberately makes no
// synchronous IPC request: This is read from inside AppKit text-input callbacks — where blocking can re-enter the
// run loop and deadlock the input method.
return m_input_caret_rect;
}
void ViewImplementation::set_input_caret_rect(Badge<WebContentClient>, Optional<Web::DevicePixelRect> rect)
{
m_input_caret_rect = rect;
}
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
void ViewImplementation::retrieved_clipboard_entries(u64 request_id, ReadonlySpan<Web::Clipboard::SystemClipboardItem> items)
LibWeb+WebContent: Add APIs to control video playback state This allows for the browser process to control the play/pause state, whether we paint user agent controls on the video, and whether the video loops when it finishes playing.
2023-05-15 12:17:58 -03:00
{
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
client().async_retrieved_clipboard_entries(page_id(), request_id, items);
LibWeb+WebContent: Add APIs to control video playback state This allows for the browser process to control the play/pause state, whether we paint user agent controls on the video, and whether the video loops when it finishes playing.
2023-05-15 12:17:58 -03:00
}
LibWeb+LibWebView+WebContent: Support muting an entire page This adds an IPC for chromes to mute a tab. When muted, we trigger an internal volume change notification and indicate that the user agent has overriden the media volume.
2024-03-30 10:41:15 -03:00
void ViewImplementation::toggle_page_mute_state()
{
m_mute_state = Web::HTML::invert_mute_state(m_mute_state);
client().async_toggle_page_mute_state(page_id());
}
LibWeb+LibWebView+WebContent: Inform chromes when audio is played/paused Most browsers have some indicator when audio is playing in a tab, which makes it easier to find that tab and mute unwanted audio. This adds an IPC to allow the Ladybird chromes to do something similar.
2024-03-26 20:27:06 -03:00
void ViewImplementation::did_change_audio_play_state(Badge<WebContentClient>, Web::HTML::AudioPlayState play_state)
{
LibWebView: Handle mutliple audio tracks when audio play state changes For example, if a page has multiple audio elements all actively playing audio, we don't want to broadcast a play state change when only one of them stop playing.
2024-03-30 10:34:23 -03:00
bool state_changed = false;
switch (play_state) {
case Web::HTML::AudioPlayState::Paused:
if (--m_number_of_elements_playing_audio == 0) {
m_audio_play_state = play_state;
state_changed = true;
}
break;
case Web::HTML::AudioPlayState::Playing:
if (m_number_of_elements_playing_audio++ == 0) {
m_audio_play_state = play_state;
state_changed = true;
}
break;
}
LibWeb+LibWebView+WebContent: Inform chromes when audio is played/paused Most browsers have some indicator when audio is playing in a tab, which makes it easier to find that tab and mute unwanted audio. This adds an IPC to allow the Ladybird chromes to do something similar.
2024-03-26 20:27:06 -03:00
LibWebView: Handle mutliple audio tracks when audio play state changes For example, if a page has multiple audio elements all actively playing audio, we don't want to broadcast a play state change when only one of them stop playing.
2024-03-30 10:34:23 -03:00
if (state_changed && on_audio_play_state_changed)
LibWeb+LibWebView+WebContent: Inform chromes when audio is played/paused Most browsers have some indicator when audio is playing in a tab, which makes it easier to find that tab and mute unwanted audio. This adds an IPC to allow the Ladybird chromes to do something similar.
2024-03-26 20:27:06 -03:00
on_audio_play_state_changed(m_audio_play_state);
}
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
void ViewImplementation::did_update_navigation_buttons_state(Badge<WebContentClient>, bool back_enabled, bool forward_enabled)
LibWeb+LibWebView+WebContent: Add did_update_navigation_buttons_state() It is going to be used to communicate whether it is possible to navigate back or forward after session history stored on browser side will no longer be used to driver navigation.
2024-04-13 18:12:55 -03:00
{
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
VERIFY(!should_manage_session_history_in_ui_process());
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
m_navigate_back_action->set_enabled(back_enabled);
m_navigate_forward_action->set_enabled(forward_enabled);
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
dump_session_history("did-update-navigation-buttons-state-using-webcontent"sv);
}
LibWeb: Stabilize same-document history mirrors Same-document navigations now commit synchronously in WebContent, while the UI process mirror learns about them over asynchronous IPC. A stale UI seed could be accepted back into a live non-initial document and overwrite its latest entry, making queued traversals target unreachable entries. Share descriptor comparison helpers between LibWeb and LibWebView. Reject stale top-level seeds against the active document latest entry, and let the UI process adopt WebContent current snapshots when a seed is rejected. Test-only session history dumps now first send WebContent current state synchronously, so dumps observe the converged state. Allow post-load UI seeds to carry UI-owned nested histories that the freshly loaded top-level document has not reconstructed yet. Add unit coverage for matching those seeds while still checking top-level state.
2026-06-15 06:27:47 -03:00
static Optional<size_t> current_top_level_history_entry_index_for_step(Vector<Web::HTML::SessionHistoryEntryDescriptor> const&, Optional<i32> current_step);
TraversableSessionHistory::UpdateResult ViewImplementation::update_session_history_from_web_content(Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, Vector<i32> used_steps, size_t current_used_step_index, bool pending_step_after_fallback_load_was_restored, bool seed_web_content_on_invalid_snapshot)
{
auto update_result = m_session_history.update_from_web_content(move(entries), move(used_steps), current_used_step_index);
m_current_web_content_session_history_matches_mirror = update_result == TraversableSessionHistory::UpdateResult::CompleteSnapshot
&& m_session_history.web_content_history_matches_mirror();
if (update_result != TraversableSessionHistory::UpdateResult::InvalidSnapshot) {
// NB: A complete WebContent snapshot means the UI-owned navigation settled, including redirected navigations
// whose final URL differs from the original pending navigation URL. A partial snapshot only updates the UI
// mirror with the current WebContent-visible subset.
if (update_result == TraversableSessionHistory::UpdateResult::CompleteSnapshot)
m_pending_session_history_navigation.clear();
if (auto* current_entry = m_session_history.current_entry()) {
auto current_url = current_entry->url;
auto const url_changed = m_url != current_url;
set_url(current_url);
if (url_changed && on_url_change)
on_url_change(m_url);
if (m_webdriver_pending_navigation_url.has_value() && *m_webdriver_pending_navigation_url != current_url)
m_webdriver_pending_navigation_url = current_url;
if (m_webdriver_pending_navigation_completes_with_session_history_update)
complete_webdriver_pending_navigation_if_url_matches(m_url);
}
if (pending_step_after_fallback_load_was_restored)
m_pending_web_content_session_history_seed.step_after_loading_top_level_entry.clear();
} else if (seed_web_content_on_invalid_snapshot) {
if (auto const* current_entry = m_session_history.current_entry(); current_entry && current_entry->url == m_url) {
prepare_to_seed_web_content_session_history_from_ui_process();
seed_web_content_session_history_from_ui_process();
}
}
update_navigation_action_state();
return update_result;
}
bool ViewImplementation::adopt_web_content_session_history_after_rejected_seed(Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, Vector<i32> used_steps, size_t current_used_step_index)
{
if (entries.is_empty())
return false;
auto entries_from_web_content = entries;
auto used_steps_from_web_content = used_steps;
auto update_result = update_session_history_from_web_content(move(entries), move(used_steps), current_used_step_index, false, false);
if (update_result == TraversableSessionHistory::UpdateResult::InvalidSnapshot && current_used_step_index < used_steps_from_web_content.size()) {
auto current_top_level_entry_index = current_top_level_history_entry_index_for_step(entries_from_web_content, used_steps_from_web_content[current_used_step_index]);
if (current_top_level_entry_index.has_value() && entries_from_web_content[*current_top_level_entry_index].url == m_url) {
m_session_history.clear();
update_result = update_session_history_from_web_content(move(entries_from_web_content), move(used_steps_from_web_content), current_used_step_index, false, false);
}
}
if (update_result == TraversableSessionHistory::UpdateResult::InvalidSnapshot)
return false;
m_pending_web_content_session_history_seed.clear();
m_pending_session_history_traversal.clear();
return true;
}
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
void ViewImplementation::did_update_session_history(Badge<WebContentClient>, Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, Vector<i32> used_steps, size_t current_used_step_index)
{
if (!should_manage_session_history_in_ui_process())
return;
if (history_debug_enabled()) {
dbgln("[History] UI received WebContent session history snapshot page={} pid={} current_used_step={} entries={} used_steps={}",
page_id(),
client().pid(),
current_used_step_index,
history_log_entries(entries),
history_log_steps(used_steps, current_used_step_index));
}
if (m_pending_web_content_session_history_seed.waiting_for_ack) {
dump_session_history("ignored-session-history-before-ui-seed-ack"sv);
update_navigation_action_state();
return;
}
auto pending_step_after_fallback_load_was_restored = false;
if (m_pending_web_content_session_history_seed.step_after_loading_top_level_entry.has_value()) {
if (current_used_step_index >= used_steps.size() || used_steps[current_used_step_index] != *m_pending_web_content_session_history_seed.step_after_loading_top_level_entry) {
dump_session_history("ignored-partial-session-history-before-fallback-seed"sv);
update_navigation_action_state();
return;
}
pending_step_after_fallback_load_was_restored = true;
}
if (m_pending_web_content_session_history_seed.ignore_updates_until_seed) {
dump_session_history("ignored-session-history-before-ui-seed"sv);
update_navigation_action_state();
return;
}
LibWeb: Stabilize same-document history mirrors Same-document navigations now commit synchronously in WebContent, while the UI process mirror learns about them over asynchronous IPC. A stale UI seed could be accepted back into a live non-initial document and overwrite its latest entry, making queued traversals target unreachable entries. Share descriptor comparison helpers between LibWeb and LibWebView. Reject stale top-level seeds against the active document latest entry, and let the UI process adopt WebContent current snapshots when a seed is rejected. Test-only session history dumps now first send WebContent current state synchronously, so dumps observe the converged state. Allow post-load UI seeds to carry UI-owned nested histories that the freshly loaded top-level document has not reconstructed yet. Add unit coverage for matching those seeds while still checking top-level state.
2026-06-15 06:27:47 -03:00
update_session_history_from_web_content(move(entries), move(used_steps), current_used_step_index, pending_step_after_fallback_load_was_restored, true);
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
dump_session_history("did-update-session-history"sv);
LibWeb+LibWebView+WebContent: Add did_update_navigation_buttons_state() It is going to be used to communicate whether it is possible to navigate back or forward after session history stored on browser side will no longer be used to driver navigation.
2024-04-13 18:12:55 -03:00
}
LibWeb: Stabilize same-document history mirrors Same-document navigations now commit synchronously in WebContent, while the UI process mirror learns about them over asynchronous IPC. A stale UI seed could be accepted back into a live non-initial document and overwrite its latest entry, making queued traversals target unreachable entries. Share descriptor comparison helpers between LibWeb and LibWebView. Reject stale top-level seeds against the active document latest entry, and let the UI process adopt WebContent current snapshots when a seed is rejected. Test-only session history dumps now first send WebContent current state synchronously, so dumps observe the converged state. Allow post-load UI seeds to carry UI-owned nested histories that the freshly loaded top-level document has not reconstructed yet. Add unit coverage for matching those seeds while still checking top-level state.
2026-06-15 06:27:47 -03:00
void ViewImplementation::did_update_session_history_for_testing(Badge<WebContentClient>, Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, Vector<i32> used_steps, size_t current_used_step_index)
{
if (!should_manage_session_history_in_ui_process())
return;
// NB: dumpUIProcessSessionHistory() first sends WebContent's current snapshot to the UI process, then returns
// the UI mirror. If a stale seed ack is still pending, normal async snapshots are intentionally ignored, so
// use the same convergence path as a rejected seed ack to make this testing hook deterministic.
if (m_pending_web_content_session_history_seed.waiting_for_ack) {
if (adopt_web_content_session_history_after_rejected_seed(move(entries), move(used_steps), current_used_step_index))
dump_session_history("did-update-session-history-for-testing-after-rejected-seed"sv);
else
dump_session_history("ignored-session-history-for-testing-before-ui-seed-ack"sv);
return;
}
update_session_history_from_web_content(move(entries), move(used_steps), current_used_step_index, false, true);
dump_session_history("did-update-session-history-for-testing"sv);
}
LibWebView: Fast-close pages without beforeunload prompts Track whether WebContent still needs a beforeunload check and let the frontends immediately remove a tab or window when no prompt can be shown. WebContent still receives the close request so pagehide, unload, and cleanup steps can run. When the visible view is removed immediately, keep detached ownership of the WebContent page until it reports that the top-level traversable closed. If no acknowledgement arrives, release detached ownership and ask ProcessManager to shut down the unused WebContent process.
2026-05-26 13:03:07 -03:00
void ViewImplementation::did_change_needs_beforeunload_check(Badge<WebContentClient>, bool needs_beforeunload_check)
{
m_needs_beforeunload_check = needs_beforeunload_check;
}
LibWebView: Use page background color while resizing Notify the UI process with the solid canvas background color recorded for the top-level document. This is the Canvas system color with the effective document background composited over it, matching the color used before normal painting. Store that color on the view and use it when AppKit, Qt, and Gtk need to fill areas exposed while an older bitmap is still on screen during a window resize.
2026-05-24 15:44:30 -03:00
void ViewImplementation::did_change_background_color(Badge<WebContentClient>, Gfx::Color color)
LibWebView: Avoid white initial web view fills in dark mode Seed the page background fallback from the platform color scheme before WebContent has painted. Update the same fallback when the platform theme changes, and when the preferred color scheme is forced through the debug menu, so unpainted web view areas use the matching Canvas color.
2026-05-26 20:11:14 -03:00
{
set_page_background_color(color);
}
void ViewImplementation::set_page_background_color_to_system_canvas(bool dark)
{
auto color_scheme = dark ? Web::CSS::PreferredColorScheme::Dark : Web::CSS::PreferredColorScheme::Light;
m_system_canvas_background_color = Web::CSS::SystemColor::canvas(color_scheme);
LibWebView: Track forced color scheme for fallback fills Remember the preferred color scheme selected through the debug menu when choosing the web view fallback background. Keep using an explicit forced scheme even if the platform theme changes underneath it.
2026-05-27 05:25:08 -03:00
set_page_background_color(preferred_canvas_background_color());
LibWebView: Avoid white initial web view fills in dark mode Seed the page background fallback from the platform color scheme before WebContent has painted. Update the same fallback when the platform theme changes, and when the preferred color scheme is forced through the debug menu, so unpainted web view areas use the matching Canvas color.
2026-05-26 20:11:14 -03:00
}
void ViewImplementation::set_page_background_color(Gfx::Color color)
LibWebView: Use page background color while resizing Notify the UI process with the solid canvas background color recorded for the top-level document. This is the Canvas system color with the effective document background composited over it, matching the color used before normal painting. Store that color on the view and use it when AppKit, Qt, and Gtk need to fill areas exposed while an older bitmap is still on screen during a window resize.
2026-05-24 15:44:30 -03:00
{
m_page_background_color = color;
if (on_page_background_color_change)
LibWebView: Avoid white initial web view fills in dark mode Seed the page background fallback from the platform color scheme before WebContent has painted. Update the same fallback when the platform theme changes, and when the preferred color scheme is forced through the debug menu, so unpainted web view areas use the matching Canvas color.
2026-05-26 20:11:14 -03:00
on_page_background_color_change(m_page_background_color);
LibWebView: Use page background color while resizing Notify the UI process with the solid canvas background color recorded for the top-level document. This is the Canvas system color with the effective document background composited over it, matching the color used before normal painting. Store that color on the view and use it when AppKit, Qt, and Gtk need to fill areas exposed while an older bitmap is still on screen during a window resize.
2026-05-24 15:44:30 -03:00
}
LibWebView: Track forced color scheme for fallback fills Remember the preferred color scheme selected through the debug menu when choosing the web view fallback background. Keep using an explicit forced scheme even if the platform theme changes underneath it.
2026-05-27 05:25:08 -03:00
Gfx::Color ViewImplementation::preferred_canvas_background_color() const
{
if (m_preferred_color_scheme == Web::CSS::PreferredColorScheme::Dark)
return Web::CSS::SystemColor::canvas(Web::CSS::PreferredColorScheme::Dark);
if (m_preferred_color_scheme == Web::CSS::PreferredColorScheme::Light)
return Web::CSS::SystemColor::canvas(Web::CSS::PreferredColorScheme::Light);
return m_system_canvas_background_color;
}
Everywhere: Replace SharedBackingStore with Gfx::SharedImage Generalize the backing store sharing abstraction into SharedImage, which represents shared GPU memory independently of Skia and can be used to share memory between different processes or different GPU contexts.
2026-04-07 13:35:26 -03:00
void ViewImplementation::did_allocate_backing_stores(Badge<WebContentClient>, i32 front_bitmap_id, Gfx::SharedImage front_backing_store, i32 back_bitmap_id, Gfx::SharedImage back_backing_store)
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 02:59:51 -03:00
{
LibWeb: Add compositor debug logging Trace the compositor state transitions that matter once presentation and async scrolling share one path: page registration, backing-store swaps, did_paint delivery, ready_to_paint acknowledgements, wheel admission, and deferred presents waiting for reusable bitmaps. Keep the logs under COMPOSITOR_DEBUG and use the [Compositor] prefix consistently. The trace is about ownership and backpressure instead of dumping every wheel event detail, so stalls can be diagnosed without reintroducing noisy async-scrolling-only logging.
2026-05-11 16:48:43 -03:00
dbgln_if(COMPOSITOR_DEBUG, "[Compositor] UI installing backing stores for page {} front={} back={} had_usable_bitmap={}",
page_id(), front_bitmap_id, back_bitmap_id, m_client_state.has_usable_bitmap);
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 02:59:51 -03:00
if (m_client_state.has_usable_bitmap) {
// NOTE: We keep the outgoing front bitmap as a backup so we have something to paint until we get a new one.
Everywhere: Replace SharedBackingStore with Gfx::SharedImage Generalize the backing store sharing abstraction into SharedImage, which represents shared GPU memory independently of Skia and can be used to share memory between different processes or different GPU contexts.
2026-04-07 13:35:26 -03:00
m_backup_shared_image_buffer = move(m_client_state.front_bitmap.shared_image_buffer);
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 02:59:51 -03:00
m_backup_bitmap_size = m_client_state.front_bitmap.last_painted_size;
}
m_client_state.has_usable_bitmap = false;
LibWebView+WebContent: Move backing store allocation into WebContent In the upcoming changes, we are going to switch macOS to using an IOSurface for the backing store. This change will simplify the process of sharing an IOSurface between processes because we already have the MachPortServer running in the browser, and WebContent knows how to locate the corresponding server.
2024-06-17 12:50:57 -03:00
m_client_state.front_bitmap.id = front_bitmap_id;
m_client_state.back_bitmap.id = back_bitmap_id;
Everywhere: Replace SharedBackingStore with Gfx::SharedImage Generalize the backing store sharing abstraction into SharedImage, which represents shared GPU memory independently of Skia and can be used to share memory between different processes or different GPU contexts.
2026-04-07 13:35:26 -03:00
m_client_state.front_bitmap.shared_image_buffer = make<Gfx::SharedImageBuffer>(Gfx::SharedImageBuffer::import_from_shared_image(move(front_backing_store)));
m_client_state.back_bitmap.shared_image_buffer = make<Gfx::SharedImageBuffer>(Gfx::SharedImageBuffer::import_from_shared_image(move(back_backing_store)));
Everywhere: Send IOSurface backing stores via main IPC route on macOS Now that LibIPC uses Mach ports for transport on macOS, IOSurface port rights can be sent as regular IPC message attachments instead of through a separate ad-hoc Mach message side-channel. Introduce Web::SharedBackingStore that wraps either a MachPort (macOS) or ShareableBitmap (other platforms) with IPC encode/decode support, unifying backing store allocation into the existing did_allocate_backing_stores IPC message.
2026-03-23 17:58:03 -03:00
}
Everywhere: Use IOSurface as backing store on macOS Using mmap-allocated memory for backing stores does not allow us to benefit from using GPU-accelerated painting, because all the performance increase we get is mostly negated by reading the GPU-allocated texture back into RAM, so it can be shared with the browser process. With IOSurface, we get a framebuffer that is both shareable between processes and can be used as underlying memory for an OpenGL/Metal texture. This change does not yet benefit from using IOSurface and merely wraps them into Gfx::Bitmap to be used by the CPU painter.
2024-06-20 15:34:51 -03:00
LibWebView+UI: Generate the zoom menu
2025-09-10 08:23:15 -03:00
void ViewImplementation::update_zoom()
{
LibWeb+WebContent: Allow WebContent to disentangle zoom from css pixels So Ladybird can paint scrollbar & resizer chrome at the same size regardless of zoom level while still respecting device pixel ratio
2026-01-05 22:05:10 -03:00
if (m_zoom_level != 1.0) {
LibWebView+UI: Generate the zoom menu
2025-09-10 08:23:15 -03:00
m_reset_zoom_action->set_text(MUST(String::formatted("{}%", round_to<int>(m_zoom_level * 100))));
m_reset_zoom_action->set_visible(true);
} else {
m_reset_zoom_action->set_visible(false);
}
LibWeb+WebContent: Allow WebContent to disentangle zoom from css pixels So Ladybird can paint scrollbar & resizer chrome at the same size regardless of zoom level while still respecting device pixel ratio
2026-01-05 22:05:10 -03:00
client().async_set_zoom_level(m_client_state.page_index, m_zoom_level);
LibWebView+UI: Generate the zoom menu
2025-09-10 08:23:15 -03:00
}
LibWebView: Persist and restore zoom level per host Remember the zoom level for each host so that returning to a site restores the zoom the user previously chose, matching what other browsers have done for years. When the user zooms in, zooms out, or resets the zoom, the resulting level is written to Settings keyed by the current page's host. On navigation, when a view's URL host changes, the stored level for the new host is applied (or the global default if there is no override). Per-host zoom changes are broadcast through the SettingsObserver so that two tabs viewing the same host stay in sync as soon as the user adjusts zoom in either one. Zoom changes from within the page (such as internals.setBrowserZoom hook) and the WebContent restart path do not persist, only user-initiated zoom changes do.
2026-05-04 15:59:22 -03:00
String ViewImplementation::current_host() const
{
if (!m_url.host().has_value())
return {};
return m_url.serialized_host();
}
void ViewImplementation::apply_zoom_for_current_host()
{
auto& settings = Application::settings();
auto zoom_level = settings.zoom_for_host(current_host()).value_or(settings.default_zoom_level_factor());
if (zoom_level == m_zoom_level)
return;
m_zoom_level = zoom_level;
update_zoom();
}
LibWebView+WebContent: Move backing store allocation into WebContent In the upcoming changes, we are going to switch macOS to using an IOSurface for the backing store. This change will simplify the process of sharing an IOSurface between processes because we already have the MachPortServer running in the browser, and WebContent knows how to locate the corresponding server.
2024-06-17 12:50:57 -03:00
void ViewImplementation::handle_resize()
{
Everywhere: Add an is_fullscreen parameter to set_viewport This will be used by the UIs to notify WebContent when fullscreen for content is entered or exited.
2026-03-16 21:28:02 -03:00
client().async_set_viewport(page_id(), viewport_size(), m_device_pixel_ratio, m_is_fullscreen);
LibWebView: Mark compositor viewport updates as resizing Tell the compositor that viewport updates from handle_resize are part of a resize operation. This keeps the compositor backing store manager on its padded live-resize path instead of forcing an exact-size backing store allocation for every browser window resize tick.
2026-05-25 21:56:25 -03:00
Application::the().update_compositor_viewport(client().compositor_context_id_for_page(page_id()), viewport_size().to_type<int>(), Web::Compositor::WindowResizingInProgress::Yes);
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 02:59:51 -03:00
}
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 18:35:17 -03:00
void ViewImplementation::initialize_client(CreateNewClient create_new_client)
{
LibWebView: Fast-close pages without beforeunload prompts Track whether WebContent still needs a beforeunload check and let the frontends immediately remove a tab or window when no prompt can be shown. WebContent still receives the close request so pagehide, unload, and cleanup steps can run. When the visible view is removed immediately, keep detached ownership of the WebContent page until it reports that the top-level traversable closed. If no acknowledgement arrives, release detached ownership and ask ProcessManager to shut down the unused WebContent process.
2026-05-26 13:03:07 -03:00
m_needs_beforeunload_check = true;
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 18:35:17 -03:00
if (create_new_client == CreateNewClient::Yes) {
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
auto client_handle = m_client_state.client_handle;
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 18:35:17 -03:00
m_client_state = {};
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
m_client_state.client_handle = move(client_handle);
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 18:35:17 -03:00
LibWebView: Create a spare WebContent process Since cross-site navigation is a pretty frequent task, creating a spare process is commonplace in other browsers to reduce the overhead of directing the target site to a new process. We store this process on the WebView application. If it is unavailable, we queue a task to create it later.
2025-03-09 19:01:25 -03:00
// FIXME: Fail to open the tab, rather than crashing the whole application if this fails.
m_client_state.client = Application::the().launch_web_content_process(*this).release_value_but_fixme_should_propagate_errors();
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 18:35:17 -03:00
} else {
m_client_state.client->register_view(m_client_state.page_index, *this);
}
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
if (m_client_state.client_handle.is_empty())
m_client_state.client_handle = Web::Crypto::generate_random_uuid();
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 18:35:17 -03:00
client().async_set_window_handle(m_client_state.page_index, m_client_state.client_handle);
LibWeb+WebContent: Allow WebContent to disentangle zoom from css pixels So Ladybird can paint scrollbar & resizer chrome at the same size regardless of zoom level while still respecting device pixel ratio
2026-01-05 22:05:10 -03:00
client().async_set_zoom_level(m_client_state.page_index, m_zoom_level);
Everywhere: Add an is_fullscreen parameter to set_viewport This will be used by the UIs to notify WebContent when fullscreen for content is entered or exited.
2026-03-16 21:28:02 -03:00
client().async_set_viewport(m_client_state.page_index, viewport_size(), m_device_pixel_ratio, m_is_fullscreen);
LibWebView+WebContent: Make it possible to change the painting interval This allows us to paint at the refresh rate of the screen. The default is 60, as before, in case it never gets set by anything.
2025-07-25 09:10:00 -03:00
client().async_set_maximum_frames_per_second(m_client_state.page_index, m_maximum_frames_per_second);
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 18:35:17 -03:00
client().async_set_system_visibility_state(m_client_state.page_index, m_system_visibility_state);
LibWebView+WebContent: Remove compositor thread option Remove the command-line option that allowed Browser to start WebContent with the in-process compositor thread instead of the Compositor helper process. The compositor process is now the default path, so the opt-out flag and the matching WebContent selector only kept the old thread mode reachable. With that option gone, simplify Browser and WebContent startup to wire each WebContent process to the Compositor process directly. The old local Browser-to-WebContent compositor IPC setup and its fallback input and ready-to-paint branches are no longer needed.
2026-05-24 16:51:33 -03:00
auto compositor_context_id = client().compositor_context_id_for_page(m_client_state.page_index);
Application::the().update_compositor_viewport(compositor_context_id, viewport_size().to_type<int>());
LibWeb+LibWebView+WebContent: Implement versioning for document cookies This patch introduces a cookie cache in the WebContent process to reduce blocking IPC calls when JS accesses document.cookie. The UI process now maintains a cookie version counter per-domain in shared memory. When JS reads document.cookie, we check whether we have a valid cached cookie by comparing the current shared version to the last used version. If they match, the cached cookie is returned without IPC. This optimization is based on Chromium's shared versioning, in which it was observed that 87% of document.cookie accesses were redundant. See: https://blog.chromium.org/2024/06/introducing-shared-memory-versioning-to.html Note that this cache only supports document.cookie, not HTTP Cookie headers. HTTP cookies are attached to requests with varying URLs and paths. The cookies that match the document URL might not match the request URL, which we wouldn't know from WebContent. So attaching the cached document cookie would be incorrect. On https://twinings.co.uk, we see approximately 600 document.cookie requests while the page loads. This patch reduces the time spent in the document.cookie getter from ~45ms to 2-3ms.
2026-02-01 15:27:19 -03:00
client().async_set_document_cookie_version_buffer(m_client_state.page_index, m_document_cookie_version_buffer);
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 18:35:17 -03:00
Everywhere: Remove dynamic Mach bootstrap registration on macOS Registering multiple Mach port names with the bootstrap server at runtime is not how macOS expects it to be used — the bootstrap server is meant for static services, and the only reason we used it originally was so child processes could reach back to the UI process. Remove bootstrap_transport_over_socket(), which had both sides register dynamic names with the bootstrap server and exchange them over a socket. Instead, WebDriver and BrowserProcess connections now go through MachPortServer instances directly. When a non-child process contacts a MachPortServer, the server creates a port pair on demand (detected via sysctl ppid check) and returns the local half immediately. This keeps bootstrap server usage limited to the one original case: child processes looking up their parent's MachPortServer. WebDriver Session now runs its own MachPortServer per session. --webdriver-content-path becomes --webdriver-mach-server-name on macOS. Spare WebContent launches are skipped when a WebDriver session is active to avoid bootstrap races.
2026-03-22 15:59:08 -03:00
if (auto webdriver_endpoint = Application::browser_options().webdriver_endpoint; webdriver_endpoint.has_value())
client().async_connect_to_webdriver(m_client_state.page_index, *webdriver_endpoint);
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 18:35:17 -03:00
LibWebView+UI: Generate the application debug menu By migrating the debug menu to LibWebView, the AppKit and Qt UIs are now in sync - the AppKit UI was previously missing some actions. Further, this inadvertently fixes bugs around applying debug settings to new web views, especially across site-isolated processes. We were previously not applying settings appropriately; this now "just works" in the LibWebView infra.
2025-09-03 10:00:52 -03:00
Application::the().apply_view_options({}, *this);
LibWebView+WebContent+UI: Migrate to the new autoplay settings This removes the old autoplay allowlist file in favor of the new site setting. We still support the command-line flag to enable autoplay globally, as this is needed for WPT.
2025-03-29 09:19:00 -03:00
LibWebView: Add defaultZoomLevelFactor setting and necessary plumbing
2025-08-23 13:15:31 -03:00
default_zoom_level_factor_changed();
LibWeb+LibWebView+UI: Migrate to LibWebView's language settings
2025-04-03 14:53:02 -03:00
languages_changed();
LibWeb+LibWebView+WebContent: Add a setting to control autoscrolling
2026-04-13 11:55:24 -03:00
browsing_behavior_changed();
LibWebView+WebContent+UI: Migrate to the new autoplay settings This removes the old autoplay allowlist file in favor of the new site setting. We still support the command-line flag to enable autoplay globally, as this is needed for WPT.
2025-03-29 09:19:00 -03:00
autoplay_settings_changed();
LibWeb+LibWebView+WebContent: Replace DNT with GPC Global Privacy Control aims to be a replacement for Do Not Track. DNT ended up not being a great solution, as it wasn't enforced by law. This actually resulted in the DNT header serving as an extra fingerprinting data point. GPC is becoming enforced by law in USA states such as California and Colorado. CA is further working on a bill which requires that browsers implement such an opt-out preference signal (OOPS): https://cppa.ca.gov/announcements/2025/20250911.html This patch replaces DNT with GPC and hooks up the associated settings.
2025-04-02 10:30:34 -03:00
global_privacy_control_changed();
LibDevTools: Only send network response bodies when DevTools connected To avoid unnecessary IPC traffic, we now only send network response bodies when a DevTools client is connected. This requires tracking DevTools connection state in ViewImplementation so we can propagate it to new WebContent processes created during cross-site navigation.
2026-01-15 10:28:42 -03:00
// If DevTools is connected, notify the new WebContent process.
if (m_devtools_connected)
client().async_did_connect_devtools_client(page_id());
LibWebView+UI: Handle common WebView client initialization in LibWebView No need to have every UI manually implement these common steps.
2024-11-13 18:35:17 -03:00
}
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
void ViewImplementation::did_start_navigation(URL::URL const& url, Variant<Empty, String, Web::HTML::POSTResource> document_resource, bool is_redirect, Web::Bindings::NavigationHistoryBehavior history_handling)
{
if (!should_manage_session_history_in_ui_process())
return;
if (m_should_suppress_history_for_next_load || m_should_suppress_history_for_current_load)
return;
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
if (m_session_history_entry_url_loading_from_ui_process.has_value()) {
if (*m_session_history_entry_url_loading_from_ui_process != url) {
// NB: An earlier UI-process history fallback load can start after a newer back/forward request has
// superseded it. Chromium, WebKit, and Firefox all give pending history loads an identity so stale
// traversals cannot consume state belonging to the current one. Keep the UI-owned history authoritative
// here and wait for the load matching the latest requested entry.
dump_session_history("ignored-stale-ui-history-load-start"sv);
return;
}
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
auto should_keep_preseeded_web_content_history = m_pending_web_content_session_history_seed.waiting_for_ack || m_session_history.web_content_uses_ui_step_coordinates();
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
m_session_history_entry_url_loading_from_ui_process.clear();
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
if (!should_keep_preseeded_web_content_history) {
m_current_web_content_session_history_matches_mirror = false;
m_session_history.forget_web_content_state();
}
dump_session_history("did-start-navigation-from-ui-history-load"sv);
return;
}
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
if (m_pending_web_content_session_history_seed.should_send_entries || m_pending_web_content_session_history_seed.ignore_updates_until_seed || m_pending_web_content_session_history_seed.waiting_for_ack) {
if (auto const* current_entry = m_session_history.current_entry(); current_entry && current_entry->url != url) {
dump_session_history("ignored-navigation-start-before-ui-history-seed"sv);
return;
}
}
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
if (m_is_showing_crash_page) {
m_is_showing_crash_page = false;
if (auto const* current_entry = m_session_history.current_entry(); current_entry && current_entry->url == url) {
prepare_to_seed_web_content_session_history_from_ui_process();
dump_session_history("did-start-navigation-from-crash-page"sv);
return;
}
}
if (is_redirect) {
m_session_history.replace_current_entry_url(url);
if (m_pending_session_history_navigation.has_value())
m_pending_session_history_navigation->url = url;
if (m_webdriver_pending_navigation_url.has_value())
m_webdriver_pending_navigation_url = url;
m_current_web_content_session_history_matches_mirror = false;
update_navigation_action_state();
dump_session_history("did-start-navigation-redirect"sv);
return;
}
if (auto const* current_entry = m_session_history.current_entry(); current_entry && current_entry->url == url) {
if (m_pending_session_history_navigation.has_value() && m_pending_session_history_navigation->url == url)
return;
if (history_handling == Web::Bindings::NavigationHistoryBehavior::Push && m_current_web_content_session_history_matches_mirror)
m_pending_session_history_navigation = PendingSessionHistoryNavigation { url, m_session_history };
else
m_pending_session_history_navigation.clear();
if (history_handling == Web::Bindings::NavigationHistoryBehavior::Replace) {
m_session_history.replace_current_entry(url, move(document_resource));
m_current_web_content_session_history_matches_mirror = false;
update_navigation_action_state();
dump_session_history("did-start-navigation-replace-current-url"sv);
} else if (history_handling == Web::Bindings::NavigationHistoryBehavior::Push) {
m_session_history.navigate(url, move(document_resource));
m_current_web_content_session_history_matches_mirror = false;
update_navigation_action_state();
dump_session_history("did-start-navigation-push-current-url"sv);
}
return;
}
if (m_session_history.current_entry())
m_pending_session_history_navigation = PendingSessionHistoryNavigation { url, m_session_history };
else
m_pending_session_history_navigation.clear();
if (history_handling == Web::Bindings::NavigationHistoryBehavior::Replace)
m_session_history.replace_current_entry(url, move(document_resource));
else
m_session_history.navigate(url, move(document_resource));
m_current_web_content_session_history_matches_mirror = false;
update_navigation_action_state();
dump_session_history("did-start-navigation"sv);
}
void ViewImplementation::did_cancel_navigation(URL::URL const& url)
{
if (m_pending_session_history_navigation.has_value() && m_pending_session_history_navigation->url == url) {
restore_pending_session_history_navigation("did-cancel-navigation"sv);
return;
}
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
if (m_session_history_entry_url_loading_from_ui_process.has_value() && *m_session_history_entry_url_loading_from_ui_process == url) {
m_session_history_entry_url_loading_from_ui_process.clear();
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
abandon_pending_web_content_session_history_seed();
m_current_web_content_session_history_matches_mirror = false;
m_session_history.forget_web_content_state();
update_navigation_action_state();
dump_session_history("did-cancel-ui-history-load"sv);
return;
}
if (m_webdriver_pending_navigation_url.has_value()) {
m_session_history.clear_current_entry_reload_pending();
m_webdriver_pending_navigation_url = m_url;
m_webdriver_pending_navigation_completes_with_session_history_update = false;
complete_webdriver_pending_navigation_if_url_matches(m_url);
}
dump_session_history("did-cancel-navigation-ignored"sv);
}
void ViewImplementation::did_finish_navigation(URL::URL const& url)
{
if (m_webdriver_pending_navigation_url.has_value() && *m_webdriver_pending_navigation_url == url && !m_webdriver_pending_navigation_completes_with_session_history_update)
complete_webdriver_pending_navigation_if_url_matches(url);
if (m_pending_session_history_navigation.has_value() && m_pending_session_history_navigation->url == url)
m_pending_session_history_navigation.clear();
if (should_manage_session_history_in_ui_process() && m_pending_web_content_session_history_seed.should_send_entries) {
if (auto const* current_entry = m_session_history.current_entry(); current_entry && current_entry->url == url) {
m_session_history.clear_current_entry_reload_pending();
LibWeb: Stabilize same-document history mirrors Same-document navigations now commit synchronously in WebContent, while the UI process mirror learns about them over asynchronous IPC. A stale UI seed could be accepted back into a live non-initial document and overwrite its latest entry, making queued traversals target unreachable entries. Share descriptor comparison helpers between LibWeb and LibWebView. Reject stale top-level seeds against the active document latest entry, and let the UI process adopt WebContent current snapshots when a seed is rejected. Test-only session history dumps now first send WebContent current state synchronously, so dumps observe the converged state. Allow post-load UI seeds to carry UI-owned nested histories that the freshly loaded top-level document has not reconstructed yet. Add unit coverage for matching those seeds while still checking top-level state.
2026-06-15 06:27:47 -03:00
auto allow_current_entry_reconstruction = m_pending_web_content_session_history_seed.should_reseed_after_current_history_load
? AllowCurrentEntryReconstruction::Yes
: AllowCurrentEntryReconstruction::No;
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
m_pending_web_content_session_history_seed.should_reseed_after_current_history_load = false;
LibWeb: Stabilize same-document history mirrors Same-document navigations now commit synchronously in WebContent, while the UI process mirror learns about them over asynchronous IPC. A stale UI seed could be accepted back into a live non-initial document and overwrite its latest entry, making queued traversals target unreachable entries. Share descriptor comparison helpers between LibWeb and LibWebView. Reject stale top-level seeds against the active document latest entry, and let the UI process adopt WebContent current snapshots when a seed is rejected. Test-only session history dumps now first send WebContent current state synchronously, so dumps observe the converged state. Allow post-load UI seeds to carry UI-owned nested histories that the freshly loaded top-level document has not reconstructed yet. Add unit coverage for matching those seeds while still checking top-level state.
2026-06-15 06:27:47 -03:00
seed_web_content_session_history_from_ui_process(allow_current_entry_reconstruction);
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
} else {
LibWeb: Stabilize same-document history mirrors Same-document navigations now commit synchronously in WebContent, while the UI process mirror learns about them over asynchronous IPC. A stale UI seed could be accepted back into a live non-initial document and overwrite its latest entry, making queued traversals target unreachable entries. Share descriptor comparison helpers between LibWeb and LibWebView. Reject stale top-level seeds against the active document latest entry, and let the UI process adopt WebContent current snapshots when a seed is rejected. Test-only session history dumps now first send WebContent current state synchronously, so dumps observe the converged state. Allow post-load UI seeds to carry UI-owned nested histories that the freshly loaded top-level document has not reconstructed yet. Add unit coverage for matching those seeds while still checking top-level state.
2026-06-15 06:27:47 -03:00
// NB: The first finish notification from a fresh WebContent process can still report about:blank before the
// traversed-to entry is ready. Keep the pending seed state intact so partial snapshots remain ignored
// until we can seed the full UI-owned history.
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
dump_session_history("skip-seed-webcontent-session-history"sv);
}
}
}
bool ViewImplementation::restore_pending_session_history_navigation(StringView reason)
{
if (!m_pending_session_history_navigation.has_value())
return false;
auto web_content_restore_mode = m_pending_session_history_navigation->web_content_restore_mode;
m_session_history = move(m_pending_session_history_navigation->previous_session_history);
m_pending_session_history_navigation.clear();
m_pending_session_history_traversal.clear();
if (auto* current_entry = m_session_history.current_entry()) {
auto current_url = current_entry->url;
auto const url_changed = m_url != current_url;
set_url(current_url);
if (url_changed && on_url_change)
on_url_change(m_url);
if (web_content_restore_mode == PendingSessionHistoryNavigation::WebContentRestoreMode::RestoreFromUIProcess) {
prepare_to_seed_web_content_session_history_from_ui_process();
m_should_suppress_history_for_current_load = false;
m_should_suppress_history_for_next_load = false;
m_webdriver_pending_navigation_url = current_url;
m_webdriver_pending_navigation_completes_with_session_history_update = true;
load_current_session_history_entry_from_ui_process();
} else {
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
m_session_history_entry_url_loading_from_ui_process.clear();
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
abandon_pending_web_content_session_history_seed();
m_current_web_content_session_history_matches_mirror = m_session_history.web_content_history_matches_mirror();
m_webdriver_pending_navigation_url.clear();
m_webdriver_pending_navigation_completes_with_session_history_update = false;
complete_webdriver_pending_navigation_if_url_matches(current_url);
}
} else {
m_current_web_content_session_history_matches_mirror = false;
}
update_navigation_action_state();
dump_session_history(reason);
return true;
}
void ViewImplementation::abandon_pending_web_content_session_history_seed()
{
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
m_session_history_entry_url_loading_from_ui_process.clear();
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
m_pending_web_content_session_history_seed.clear();
}
StringView ViewImplementation::pending_session_history_navigation_web_content_restore_mode_to_string(PendingSessionHistoryNavigation::WebContentRestoreMode mode)
{
switch (mode) {
case PendingSessionHistoryNavigation::WebContentRestoreMode::PreserveCurrentProcessState:
return "preserve-current-process-state"sv;
case PendingSessionHistoryNavigation::WebContentRestoreMode::RestoreFromUIProcess:
return "restore-from-ui-process"sv;
}
VERIFY_NOT_REACHED();
}
StringView ViewImplementation::pending_session_history_traversal_stage_to_string(PendingSessionHistoryTraversal::Stage stage)
{
switch (stage) {
case PendingSessionHistoryTraversal::Stage::ApplyingInWebContent:
return "applying-in-webcontent"sv;
case PendingSessionHistoryTraversal::Stage::CheckingCancelation:
return "checking-cancelation"sv;
case PendingSessionHistoryTraversal::Stage::LoadingEntryFromUIProcess:
return "loading-entry-from-ui-process"sv;
case PendingSessionHistoryTraversal::Stage::ReplacingWebContentProcess:
return "replacing-webcontent-process"sv;
case PendingSessionHistoryTraversal::Stage::RestoringNestedStepAfterSeed:
return "restoring-nested-step-after-seed"sv;
}
VERIFY_NOT_REACHED();
}
static Optional<size_t> current_top_level_history_entry_index_for_step(Vector<Web::HTML::SessionHistoryEntryDescriptor> const& entries, Optional<i32> current_step)
{
if (!current_step.has_value())
return {};
Optional<size_t> current_entry_index;
for (size_t i = 0; i < entries.size(); ++i) {
if (entries[i].step > *current_step)
break;
current_entry_index = i;
}
return current_entry_index;
}
void ViewImplementation::did_start_webdriver_navigation(Badge<WebContentClient>, URL::URL const& url)
{
m_webdriver_pending_navigation_url = url;
m_webdriver_pending_navigation_completes_with_session_history_update = false;
}
void ViewImplementation::wait_for_webdriver_navigation_completion(Badge<WebContentClient>, Optional<u64> page_load_timeout, Function<void(Web::WebDriver::Response)> on_complete)
{
if (!m_webdriver_pending_navigation_url.has_value()) {
on_complete(JsonValue {});
return;
}
auto request_id = m_next_webdriver_navigation_completion_request_id++;
auto request = make<WebDriverNavigationCompletionRequest>();
request->on_complete = move(on_complete);
m_pending_webdriver_navigation_completion_requests.set(request_id, move(request));
auto listener_id = add_navigation_listener({
.on_load_start = nullptr,
.on_load_finish = [this](URL::URL const& url) {
complete_webdriver_pending_navigation_if_url_matches(url);
},
});
m_pending_webdriver_navigation_completion_requests.get(request_id).value()->navigation_listener_id = listener_id;
if (page_load_timeout.has_value()) {
auto timer_interval = *page_load_timeout > NumericLimits<int>::max() ? NumericLimits<int>::max() : static_cast<int>(*page_load_timeout);
auto timer = Core::Timer::create_single_shot(timer_interval, [this, request_id] {
complete_webdriver_navigation_completion(request_id, Web::WebDriver::Error::from_code(Web::WebDriver::ErrorCode::Timeout, "Navigation timed out"sv));
});
timer->start();
m_pending_webdriver_navigation_completion_requests.get(request_id).value()->timer = move(timer);
}
}
void ViewImplementation::complete_webdriver_navigation_completion(u64 request_id, Web::WebDriver::Response response)
{
auto maybe_request = m_pending_webdriver_navigation_completion_requests.take(request_id);
if (!maybe_request.has_value())
return;
auto request = maybe_request.release_value();
remove_navigation_listener(request->navigation_listener_id);
if (request->timer)
request->timer->stop();
request->on_complete(move(response));
}
void ViewImplementation::complete_webdriver_pending_navigation_if_url_matches(URL::URL const& url)
{
if (m_webdriver_pending_navigation_url.has_value() && *m_webdriver_pending_navigation_url != url)
return;
m_webdriver_pending_navigation_url.clear();
m_webdriver_pending_navigation_completes_with_session_history_update = false;
Vector<u64> request_ids;
request_ids.ensure_capacity(m_pending_webdriver_navigation_completion_requests.size());
for (auto const& request : m_pending_webdriver_navigation_completion_requests)
request_ids.unchecked_append(request.key);
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
auto view_id = m_view_id;
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
for (auto request_id : request_ids) {
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
Core::EventLoop::current().deferred_invoke([view_id, request_id] {
auto view = ViewImplementation::find_view_by_id(view_id);
if (!view.has_value())
return;
view->complete_webdriver_navigation_completion(request_id, JsonValue {});
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
});
}
}
JsonValue ViewImplementation::webdriver_session_history() const
{
JsonObject serialized;
serialized.set("currentURL"sv, m_url.serialize());
serialized.set("webContentProcessID"sv, client().pid());
serialized.set("backButtonEnabled"sv, m_navigate_back_action->enabled());
serialized.set("forwardButtonEnabled"sv, m_navigate_forward_action->enabled());
serialized.set("webContentHistoryMatchesUI"sv, m_current_web_content_session_history_matches_mirror);
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
serialized.set("loadingSessionHistoryEntryFromUI"sv, m_session_history_entry_url_loading_from_ui_process.has_value());
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
serialized.set("waitingToSeedWebContent"sv, m_pending_web_content_session_history_seed.should_send_entries);
serialized.set("waitingForWebContentSeedAck"sv, m_pending_web_content_session_history_seed.waiting_for_ack);
serialized.set("ignoringWebContentUpdatesUntilSeed"sv, m_pending_web_content_session_history_seed.ignore_updates_until_seed);
serialized.set("reseedAfterCurrentHistoryLoad"sv, m_pending_web_content_session_history_seed.should_reseed_after_current_history_load);
serialized.set("hasOnlyTopLevelUsedSteps"sv, m_session_history.has_only_top_level_used_steps());
serialized.set("webContentUsesUIStepCoordinates"sv, m_session_history.web_content_uses_ui_step_coordinates());
auto web_content_known_entries = m_session_history.web_content_known_entries();
auto web_content_known_used_steps = m_session_history.web_content_known_used_steps();
auto web_content_current_step = m_session_history.web_content_current_step();
Optional<size_t> web_content_current_step_index;
if (web_content_current_step.has_value())
web_content_current_step_index = web_content_known_used_steps.find_first_index(*web_content_current_step);
serialized.set("webContentKnownEntries"sv, history_json_entries(web_content_known_entries, current_top_level_history_entry_index_for_step(web_content_known_entries, web_content_current_step)));
serialized.set("webContentKnownUsedSteps"sv, history_json_steps(web_content_known_used_steps, web_content_current_step_index));
if (web_content_current_step.has_value())
serialized.set("webContentCurrentStep"sv, *web_content_current_step);
else
serialized.set("webContentCurrentStep"sv, JsonValue {});
if (auto current_used_step_index = m_session_history.current_used_step_index(); current_used_step_index.has_value())
serialized.set("currentUsedStepIndex"sv, *current_used_step_index);
else
serialized.set("currentUsedStepIndex"sv, JsonValue {});
if (auto pending_step = m_pending_web_content_session_history_seed.step_after_loading_top_level_entry; pending_step.has_value())
serialized.set("pendingWebContentHistoryStepAfterFallbackLoad"sv, *pending_step);
else
serialized.set("pendingWebContentHistoryStepAfterFallbackLoad"sv, JsonValue {});
if (m_pending_session_history_navigation.has_value()) {
JsonObject pending_navigation;
pending_navigation.set("url"sv, m_pending_session_history_navigation->url.serialize());
pending_navigation.set("webContentRestoreMode"sv, pending_session_history_navigation_web_content_restore_mode_to_string(m_pending_session_history_navigation->web_content_restore_mode));
if (auto const* previous_current_entry = m_pending_session_history_navigation->previous_session_history.current_entry())
pending_navigation.set("previousCurrentURL"sv, previous_current_entry->url.serialize());
else
pending_navigation.set("previousCurrentURL"sv, JsonValue {});
serialized.set("pendingSessionHistoryNavigation"sv, move(pending_navigation));
} else {
serialized.set("pendingSessionHistoryNavigation"sv, JsonValue {});
}
if (m_pending_session_history_traversal.has_value()) {
JsonObject pending_traversal;
pending_traversal.set("targetStep"sv, m_pending_session_history_traversal->target_step);
pending_traversal.set("targetStepIndex"sv, m_pending_session_history_traversal->target_step_index);
pending_traversal.set("willChangeTopLevelEntry"sv, m_pending_session_history_traversal->will_change_top_level_entry);
pending_traversal.set("willReplaceWebContentProcess"sv, m_pending_session_history_traversal->will_replace_web_content_process);
pending_traversal.set("stage"sv, pending_session_history_traversal_stage_to_string(m_pending_session_history_traversal->stage));
serialized.set("pendingSessionHistoryTraversal"sv, move(pending_traversal));
} else {
serialized.set("pendingSessionHistoryTraversal"sv, JsonValue {});
}
serialized.set("entries"sv, history_json_entries(m_session_history));
serialized.set("usedSteps"sv, history_json_steps(m_session_history));
return serialized;
}
String ViewImplementation::ui_process_session_history_for_testing(Badge<WebContentClient>) const
{
return webdriver_session_history().serialized();
}
void ViewImplementation::update_navigation_action_state()
{
m_navigate_back_action->set_enabled(m_session_history.can_go_back());
m_navigate_forward_action->set_enabled(m_session_history.can_go_forward());
}
LibWeb: Stabilize same-document history mirrors Same-document navigations now commit synchronously in WebContent, while the UI process mirror learns about them over asynchronous IPC. A stale UI seed could be accepted back into a live non-initial document and overwrite its latest entry, making queued traversals target unreachable entries. Share descriptor comparison helpers between LibWeb and LibWebView. Reject stale top-level seeds against the active document latest entry, and let the UI process adopt WebContent current snapshots when a seed is rejected. Test-only session history dumps now first send WebContent current state synchronously, so dumps observe the converged state. Allow post-load UI seeds to carry UI-owned nested histories that the freshly loaded top-level document has not reconstructed yet. Add unit coverage for matching those seeds while still checking top-level state.
2026-06-15 06:27:47 -03:00
void ViewImplementation::seed_web_content_session_history_from_ui_process(AllowCurrentEntryReconstruction allow_current_entry_reconstruction)
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
{
auto current_top_level_entry_index = m_session_history.current_top_level_entry_index();
if (!current_top_level_entry_index.has_value()) {
abandon_pending_web_content_session_history_seed();
m_current_web_content_session_history_matches_mirror = false;
m_session_history.forget_web_content_state();
update_navigation_action_state();
dump_session_history("skip-webcontent-session-history-seed-without-current-entry"sv);
return;
}
auto entries = m_session_history.entries();
if (entries.is_empty()) {
abandon_pending_web_content_session_history_seed();
m_current_web_content_session_history_matches_mirror = false;
m_session_history.forget_web_content_state();
update_navigation_action_state();
dump_session_history("skip-webcontent-session-history-seed-without-entries"sv);
return;
}
if (history_debug_enabled()) {
dbgln("[History] UI seeds WebContent session history page={} pid={} current={} entries={}",
page_id(),
client().pid(),
*current_top_level_entry_index,
history_log_entries(entries, current_top_level_entry_index));
}
LibWeb: Stabilize same-document history mirrors Same-document navigations now commit synchronously in WebContent, while the UI process mirror learns about them over asynchronous IPC. A stale UI seed could be accepted back into a live non-initial document and overwrite its latest entry, making queued traversals target unreachable entries. Share descriptor comparison helpers between LibWeb and LibWebView. Reject stale top-level seeds against the active document latest entry, and let the UI process adopt WebContent current snapshots when a seed is rejected. Test-only session history dumps now first send WebContent current state synchronously, so dumps observe the converged state. Allow post-load UI seeds to carry UI-owned nested histories that the freshly loaded top-level document has not reconstructed yet. Add unit coverage for matching those seeds while still checking top-level state.
2026-06-15 06:27:47 -03:00
// NB: A fallback traversal or crash recovery can restore the current top-level document before WebContent has the
// UI-owned session history that surrounds it. Allow WebContent to reconstruct that current entry only while the
// UI process is actively restoring that authoritative history, including the follow-up child navigable step for
// nested history. After crash recovery there might not be a pending traversal object anymore, but a pending
// nested step still means the top-level document is only a staging point for restoring the current history
// step.
auto is_restoring_traversal_target = m_pending_session_history_traversal.has_value()
&& (m_pending_session_history_traversal->stage == PendingSessionHistoryTraversal::Stage::LoadingEntryFromUIProcess
|| m_pending_session_history_traversal->stage == PendingSessionHistoryTraversal::Stage::ReplacingWebContentProcess
|| m_pending_session_history_traversal->stage == PendingSessionHistoryTraversal::Stage::RestoringNestedStepAfterSeed);
auto allow_reconstructing_current_entry = is_restoring_traversal_target
|| m_pending_web_content_session_history_seed.step_after_loading_top_level_entry.has_value()
|| allow_current_entry_reconstruction == AllowCurrentEntryReconstruction::Yes;
client().async_set_top_level_session_history(page_id(), move(entries), *current_top_level_entry_index, allow_reconstructing_current_entry);
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
m_pending_web_content_session_history_seed.waiting_for_ack = true;
m_pending_web_content_session_history_seed.should_send_entries = false;
update_navigation_action_state();
dump_session_history("sent-webcontent-session-history-seed"sv);
}
void ViewImplementation::prepare_to_seed_web_content_session_history_from_ui_process()
{
m_current_web_content_session_history_matches_mirror = false;
m_session_history.forget_web_content_state();
m_pending_session_history_navigation.clear();
m_pending_web_content_session_history_seed.clear();
LibWeb: Stabilize same-document history mirrors Same-document navigations now commit synchronously in WebContent, while the UI process mirror learns about them over asynchronous IPC. A stale UI seed could be accepted back into a live non-initial document and overwrite its latest entry, making queued traversals target unreachable entries. Share descriptor comparison helpers between LibWeb and LibWebView. Reject stale top-level seeds against the active document latest entry, and let the UI process adopt WebContent current snapshots when a seed is rejected. Test-only session history dumps now first send WebContent current state synchronously, so dumps observe the converged state. Allow post-load UI seeds to carry UI-owned nested histories that the freshly loaded top-level document has not reconstructed yet. Add unit coverage for matching those seeds while still checking top-level state.
2026-06-15 06:27:47 -03:00
// NB: A fresh or repaired WebContent process reaches the current top-level session history entry after loading or
// reseeding m_url. If the traversable's current session history step is nested, finish restoration by
// traversing to that step after seeding the top-level entries.
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
m_pending_web_content_session_history_seed.step_after_loading_top_level_entry = m_session_history.current_step_to_restore_after_loading_top_level_entry();
m_pending_web_content_session_history_seed.should_send_entries = true;
m_pending_web_content_session_history_seed.ignore_updates_until_seed = true;
}
void ViewImplementation::restore_current_session_history_entry_from_ui_process()
{
m_webdriver_pending_navigation_url = m_url;
if (!m_pending_web_content_session_history_seed.step_after_loading_top_level_entry.has_value()) {
m_pending_web_content_session_history_seed.should_reseed_after_current_history_load = true;
seed_web_content_session_history_from_ui_process();
}
load_current_session_history_entry_from_ui_process();
}
void ViewImplementation::load_current_session_history_entry_from_ui_process()
{
auto const* current_entry = m_session_history.current_entry();
if (!current_entry) {
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
m_session_history_entry_url_loading_from_ui_process = m_url;
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
client().async_load_url(page_id(), m_url, Web::Bindings::NavigationHistoryBehavior::Auto);
return;
}
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
m_session_history_entry_url_loading_from_ui_process = current_entry->url;
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
auto history_handling = m_pending_web_content_session_history_seed.waiting_for_ack || m_session_history.web_content_uses_ui_step_coordinates()
? Web::Bindings::NavigationHistoryBehavior::Replace
: Web::Bindings::NavigationHistoryBehavior::Auto;
client().async_load_url_with_document_resource(
page_id(),
current_entry->url,
current_entry->document_state.resource,
history_handling);
}
void ViewImplementation::load_session_history_traversal_target_from_ui_process(TraversableSessionHistory::TraversalTarget const& target, StringView dump_reason)
{
if (!m_pending_session_history_traversal.has_value() || m_pending_session_history_traversal->target_step != target.target_step) {
m_pending_session_history_traversal = PendingSessionHistoryTraversal {
.target_step = target.target_step,
.target_step_index = target.target_step_index,
.will_change_top_level_entry = target.changes_top_level_entry,
.will_replace_web_content_process = !is_url_suitable_for_same_process_navigation(m_url, target.target_top_level_entry->url),
.stage = PendingSessionHistoryTraversal::Stage::LoadingEntryFromUIProcess,
.on_cancelation_check_complete = nullptr,
};
} else {
m_pending_session_history_traversal->stage = PendingSessionHistoryTraversal::Stage::LoadingEntryFromUIProcess;
}
auto previous_session_history = m_session_history;
m_session_history.traverse_to(target.target_step_index);
update_navigation_action_state();
prepare_to_seed_web_content_session_history_from_ui_process();
m_pending_session_history_navigation = PendingSessionHistoryNavigation {
target.target_top_level_entry->url,
move(previous_session_history),
};
m_webdriver_pending_navigation_url = target.target_top_level_entry->url;
LibWeb: Stabilize same-document history mirrors Same-document navigations now commit synchronously in WebContent, while the UI process mirror learns about them over asynchronous IPC. A stale UI seed could be accepted back into a live non-initial document and overwrite its latest entry, making queued traversals target unreachable entries. Share descriptor comparison helpers between LibWeb and LibWebView. Reject stale top-level seeds against the active document latest entry, and let the UI process adopt WebContent current snapshots when a seed is rejected. Test-only session history dumps now first send WebContent current state synchronously, so dumps observe the converged state. Allow post-load UI seeds to carry UI-owned nested histories that the freshly loaded top-level document has not reconstructed yet. Add unit coverage for matching those seeds while still checking top-level state.
2026-06-15 06:27:47 -03:00
// NB: A UI-process fallback traversal is only fully observable once the replacement WebContent process has
// accepted the UI-owned history seed. Completing WebDriver at load finish would let tests, and callers doing
// immediate history inspection, observe the fresh process before it has consumed the authoritative history.
m_webdriver_pending_navigation_completes_with_session_history_update = true;
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
set_url(target.target_top_level_entry->url);
dump_session_history(dump_reason);
load_current_session_history_entry_from_ui_process();
}
NonnullRefPtr<Core::Promise<Empty>> ViewImplementation::reset_session_history_for_testing()
{
m_pending_session_history_reset_for_testing = Core::Promise<Empty>::construct();
client().async_reset_session_history_for_testing(page_id());
return *m_pending_session_history_reset_for_testing;
}
void ViewImplementation::did_set_top_level_session_history(Badge<WebContentClient>, bool accepted, Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, Vector<i32> used_steps, size_t current_used_step_index)
{
if (!should_manage_session_history_in_ui_process())
return;
if (history_debug_enabled()) {
dbgln("[History] UI received WebContent session history seed ack page={} pid={} accepted={} current_used_step={} entries={} used_steps={}",
page_id(),
client().pid(),
accepted,
current_used_step_index,
history_log_entries(entries),
history_log_steps(used_steps, current_used_step_index));
}
if (!m_pending_web_content_session_history_seed.waiting_for_ack) {
dump_session_history("ignored-webcontent-session-history-seed-ack"sv);
return;
}
if (!accepted) {
LibWeb: Stabilize same-document history mirrors Same-document navigations now commit synchronously in WebContent, while the UI process mirror learns about them over asynchronous IPC. A stale UI seed could be accepted back into a live non-initial document and overwrite its latest entry, making queued traversals target unreachable entries. Share descriptor comparison helpers between LibWeb and LibWebView. Reject stale top-level seeds against the active document latest entry, and let the UI process adopt WebContent current snapshots when a seed is rejected. Test-only session history dumps now first send WebContent current state synchronously, so dumps observe the converged state. Allow post-load UI seeds to carry UI-owned nested histories that the freshly loaded top-level document has not reconstructed yet. Add unit coverage for matching those seeds while still checking top-level state.
2026-06-15 06:27:47 -03:00
// NB: WebContent can reject a stale UI-process seed without changing its live session history. In that case
// the ack carries WebContent's current snapshot, so converge the UI mirror from the same path used by
// normal WebContent history updates. If the snapshot itself is not usable, fall back to forgetting the
// WebContent state below and wait for the next repair point.
if (adopt_web_content_session_history_after_rejected_seed(move(entries), move(used_steps), current_used_step_index)) {
dump_session_history("webcontent-session-history-seed-rejected-with-current-snapshot"sv);
return;
}
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
abandon_pending_web_content_session_history_seed();
m_current_web_content_session_history_matches_mirror = false;
m_session_history.forget_web_content_state();
m_pending_session_history_traversal.clear();
update_navigation_action_state();
dump_session_history("webcontent-session-history-seed-rejected"sv);
return;
}
if (!m_session_history.did_seed_web_content_from_ui_process(move(entries), move(used_steps), current_used_step_index)) {
if (m_pending_web_content_session_history_seed.should_reseed_after_current_history_load) {
m_pending_web_content_session_history_seed.waiting_for_ack = false;
m_pending_web_content_session_history_seed.should_send_entries = true;
m_pending_web_content_session_history_seed.ignore_updates_until_seed = true;
m_current_web_content_session_history_matches_mirror = false;
update_navigation_action_state();
dump_session_history("webcontent-session-history-preload-seed-ack-mismatch"sv);
return;
}
abandon_pending_web_content_session_history_seed();
m_current_web_content_session_history_matches_mirror = false;
m_session_history.forget_web_content_state();
m_pending_session_history_traversal.clear();
update_navigation_action_state();
dump_session_history("webcontent-session-history-seed-ack-mismatch"sv);
return;
}
m_pending_web_content_session_history_seed.waiting_for_ack = false;
if (m_pending_web_content_session_history_seed.should_reseed_after_current_history_load) {
m_pending_web_content_session_history_seed.should_send_entries = true;
m_pending_web_content_session_history_seed.ignore_updates_until_seed = true;
m_current_web_content_session_history_matches_mirror = false;
update_navigation_action_state();
dump_session_history("webcontent-session-history-preload-seed-ack"sv);
return;
}
m_pending_web_content_session_history_seed.ignore_updates_until_seed = false;
LibWeb: Stabilize same-document history mirrors Same-document navigations now commit synchronously in WebContent, while the UI process mirror learns about them over asynchronous IPC. A stale UI seed could be accepted back into a live non-initial document and overwrite its latest entry, making queued traversals target unreachable entries. Share descriptor comparison helpers between LibWeb and LibWebView. Reject stale top-level seeds against the active document latest entry, and let the UI process adopt WebContent current snapshots when a seed is rejected. Test-only session history dumps now first send WebContent current state synchronously, so dumps observe the converged state. Allow post-load UI seeds to carry UI-owned nested histories that the freshly loaded top-level document has not reconstructed yet. Add unit coverage for matching those seeds while still checking top-level state.
2026-06-15 06:27:47 -03:00
// NB: A seed ack can arrive while a top-level navigation is still blocked. Keep the mirror provisional until that
// navigation settles.
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
m_current_web_content_session_history_matches_mirror = !m_pending_web_content_session_history_seed.step_after_loading_top_level_entry.has_value()
&& !m_pending_session_history_navigation.has_value();
if (m_pending_web_content_session_history_seed.step_after_loading_top_level_entry.has_value()) {
if (m_pending_session_history_traversal.has_value())
m_pending_session_history_traversal->stage = PendingSessionHistoryTraversal::Stage::RestoringNestedStepAfterSeed;
client().async_traverse_the_history_to_step(page_id(), *m_pending_web_content_session_history_seed.step_after_loading_top_level_entry);
} else {
auto is_waiting_for_history_step_cancelation_check = m_pending_session_history_traversal.has_value()
&& m_pending_session_history_traversal->stage == PendingSessionHistoryTraversal::Stage::CheckingCancelation;
if (!is_waiting_for_history_step_cancelation_check) {
m_pending_session_history_traversal.clear();
if (!m_pending_session_history_navigation.has_value())
complete_webdriver_pending_navigation_if_url_matches(m_url);
}
}
update_navigation_action_state();
dump_session_history("webcontent-session-history-seed-ack"sv);
}
void ViewImplementation::did_traverse_the_history_to_step(Badge<WebContentClient>, i32 step, bool step_was_available, Web::HTML::HistoryStepResult result)
{
if (!should_manage_session_history_in_ui_process())
return;
if (!m_pending_web_content_session_history_seed.step_after_loading_top_level_entry.has_value()) {
if (!m_pending_session_history_traversal.has_value() || m_pending_session_history_traversal->target_step != step) {
dump_session_history("ignored-stale-webcontent-history-step-result"sv);
return;
}
if (!step_was_available) {
auto target = m_session_history.traversal_target_for_step(step);
if (target.has_value()) {
load_session_history_traversal_target_from_ui_process(*target, "webcontent-history-step-unavailable-fallback-load"sv);
return;
}
m_current_web_content_session_history_matches_mirror = false;
m_session_history.forget_web_content_state();
m_pending_session_history_traversal.clear();
update_navigation_action_state();
dump_session_history("webcontent-history-step-unavailable"sv);
return;
}
if (result != Web::HTML::HistoryStepResult::Applied) {
if (m_webdriver_pending_navigation_url.has_value())
m_webdriver_pending_navigation_url = m_url;
m_webdriver_pending_navigation_completes_with_session_history_update = false;
complete_webdriver_pending_navigation_if_url_matches(m_url);
m_pending_session_history_traversal.clear();
update_navigation_action_state();
dump_session_history("webcontent-history-step-canceled"sv);
} else {
if (!m_session_history.did_apply_web_content_traversal_to_step(step)) {
if (auto target = m_session_history.traversal_target_for_step(step); target.has_value()) {
load_session_history_traversal_target_from_ui_process(*target, "webcontent-history-step-applied-with-stale-mirror-fallback-load"sv);
return;
}
m_current_web_content_session_history_matches_mirror = false;
m_session_history.forget_web_content_state();
m_pending_session_history_traversal.clear();
update_navigation_action_state();
dump_session_history("webcontent-history-step-applied-without-ui-target"sv);
return;
}
m_current_web_content_session_history_matches_mirror = true;
if (auto const* current_entry = m_session_history.current_entry()) {
auto current_url = current_entry->url;
auto const url_changed = m_url != current_url;
set_url(current_url);
if (url_changed && on_url_change)
on_url_change(m_url);
if (m_webdriver_pending_navigation_url.has_value() && *m_webdriver_pending_navigation_url != current_url)
m_webdriver_pending_navigation_url = current_url;
}
LibWebView: Complete WebDriver same-document traversals Complete pending WebDriver navigation waits when WebContent confirms that a same-document history traversal step was applied. These traversals do not always produce a load event, and waiting only for a later session history snapshot could let the WebDriver command return before the UI had observed the applied step. This keeps the WebDriver session history test from racing into later commands while a previous same-document traversal is still settling.
2026-06-14 04:58:59 -03:00
if (!m_pending_session_history_traversal->will_change_top_level_entry)
complete_webdriver_pending_navigation_if_url_matches(m_url);
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
m_pending_session_history_traversal.clear();
update_navigation_action_state();
dump_session_history("webcontent-history-step-applied"sv);
}
return;
}
if (*m_pending_web_content_session_history_seed.step_after_loading_top_level_entry != step) {
dump_session_history("ignored-stale-webcontent-history-step-result"sv);
return;
}
if (step_was_available && result == Web::HTML::HistoryStepResult::Applied) {
m_pending_web_content_session_history_seed.step_after_loading_top_level_entry.clear();
m_current_web_content_session_history_matches_mirror = m_session_history.did_restore_web_content_to_current_step(step);
m_pending_session_history_traversal.clear();
complete_webdriver_pending_navigation_if_url_matches(m_url);
update_navigation_action_state();
dump_session_history("webcontent-history-step-restored"sv);
} else {
auto reason = step_was_available ? "webcontent-pending-history-step-canceled"sv : "webcontent-history-step-unavailable"sv;
if (restore_pending_session_history_navigation(reason))
return;
m_pending_web_content_session_history_seed.step_after_loading_top_level_entry.clear();
m_current_web_content_session_history_matches_mirror = false;
m_session_history.forget_web_content_state();
m_pending_session_history_traversal.clear();
update_navigation_action_state();
dump_session_history(reason);
}
}
void ViewImplementation::did_check_if_traverse_history_step_is_canceled(
Badge<WebContentClient>, u64 request_id, i32 step, bool canceled)
{
if (!should_manage_session_history_in_ui_process())
return;
if (!m_pending_session_history_traversal.has_value()
|| m_pending_session_history_traversal->stage != PendingSessionHistoryTraversal::Stage::CheckingCancelation
|| m_pending_session_history_traversal->cancelation_check_request_id != request_id
|| m_pending_session_history_traversal->target_step != step) {
dump_session_history("ignored-stale-history-step-cancelation-check-result"sv);
return;
}
if (canceled) {
auto on_cancelation_check_complete = move(m_pending_session_history_traversal->on_cancelation_check_complete);
if (m_webdriver_pending_navigation_url.has_value())
m_webdriver_pending_navigation_url = m_url;
m_webdriver_pending_navigation_completes_with_session_history_update = false;
complete_webdriver_pending_navigation_if_url_matches(m_url);
m_pending_session_history_traversal.clear();
update_navigation_action_state();
dump_session_history("traverse-fallback-canceled-by-webcontent"sv);
if (on_cancelation_check_complete)
on_cancelation_check_complete({
.status = HistoryTraversalStatus::Canceled,
});
return;
}
auto target = m_session_history.traversal_target_for_step(step);
if (!target.has_value()) {
auto on_cancelation_check_complete = move(m_pending_session_history_traversal->on_cancelation_check_complete);
m_current_web_content_session_history_matches_mirror = false;
m_session_history.forget_web_content_state();
m_pending_session_history_traversal.clear();
update_navigation_action_state();
dump_session_history("traverse-fallback-cancelation-check-without-ui-target"sv);
if (on_cancelation_check_complete)
on_cancelation_check_complete({
.status = HistoryTraversalStatus::NoEntry,
});
return;
}
auto on_cancelation_check_complete = move(m_pending_session_history_traversal->on_cancelation_check_complete);
if (on_cancelation_check_complete)
on_cancelation_check_complete({
.status = HistoryTraversalStatus::Started,
.will_replace_web_content_process = m_pending_session_history_traversal->will_replace_web_content_process,
.will_change_top_level_entry = m_pending_session_history_traversal->will_change_top_level_entry,
});
load_session_history_traversal_target_from_ui_process(*target, "traverse-fallback-load-after-cancelation-check"sv);
}
void ViewImplementation::did_reset_session_history_for_testing(Badge<WebContentClient>)
{
auto promise = move(m_pending_session_history_reset_for_testing);
m_session_history.clear();
m_current_web_content_session_history_matches_mirror = false;
m_pending_session_history_navigation.clear();
m_pending_session_history_traversal.clear();
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
m_session_history_entry_url_loading_from_ui_process.clear();
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
abandon_pending_web_content_session_history_seed();
m_webdriver_pending_navigation_url.clear();
m_webdriver_pending_navigation_completes_with_session_history_update = false;
update_navigation_action_state();
if (promise)
promise->resolve({});
}
void ViewImplementation::mark_web_content_session_history_stale_for_testing(Badge<WebContentClient>)
{
m_current_web_content_session_history_matches_mirror = false;
update_navigation_action_state();
dump_session_history("marked-webcontent-session-history-stale-for-testing"sv);
}
void ViewImplementation::dump_session_history(StringView reason, SessionHistoryDumpMode mode) const
{
if (mode == SessionHistoryDumpMode::IfDebuggingEnabled && !history_debug_enabled())
return;
auto web_content_known_used_steps = m_session_history.web_content_known_used_steps();
auto web_content_current_step = m_session_history.web_content_current_step();
Optional<size_t> web_content_current_step_index;
if (web_content_current_step.has_value())
web_content_current_step_index = web_content_known_used_steps.find_first_index(*web_content_current_step);
auto web_content_known_entries = m_session_history.web_content_known_entries();
auto web_content_current_top_level_entry_index = current_top_level_history_entry_index_for_step(web_content_known_entries, web_content_current_step);
auto pending_navigation_url = "none"sv;
auto pending_navigation_restore_mode = "none"sv;
String pending_navigation_url_storage;
if (m_pending_session_history_navigation.has_value()) {
pending_navigation_url_storage = m_pending_session_history_navigation->url.serialize();
pending_navigation_url = pending_navigation_url_storage.bytes_as_string_view();
pending_navigation_restore_mode = pending_session_history_navigation_web_content_restore_mode_to_string(m_pending_session_history_navigation->web_content_restore_mode);
}
dbgln("[History] UI session history page={} pid={} reason={} url='{}' webcontent_matches={} webcontent_uses_ui_steps={} loading_from_ui={} waiting_to_seed={} waiting_for_seed_ack={} ignore_until_seed={} reseed_after_current_load={} pending_webcontent_step={} pending_navigation_url={} pending_navigation_restore={} pending_traversal_target={} pending_traversal_stage={} webcontent_current_step={} back={} forward={} entries={} webcontent_known_entries={} webcontent_known_used_steps={}",
page_id(),
client().pid(),
reason,
m_url,
m_current_web_content_session_history_matches_mirror,
m_session_history.web_content_uses_ui_step_coordinates(),
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
m_session_history_entry_url_loading_from_ui_process.has_value(),
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
m_pending_web_content_session_history_seed.should_send_entries,
m_pending_web_content_session_history_seed.waiting_for_ack,
m_pending_web_content_session_history_seed.ignore_updates_until_seed,
m_pending_web_content_session_history_seed.should_reseed_after_current_history_load,
m_pending_web_content_session_history_seed.step_after_loading_top_level_entry,
pending_navigation_url,
pending_navigation_restore_mode,
m_pending_session_history_traversal.has_value() ? Optional<i32> { m_pending_session_history_traversal->target_step } : Optional<i32> {},
m_pending_session_history_traversal.has_value() ? pending_session_history_traversal_stage_to_string(m_pending_session_history_traversal->stage) : "none"sv,
web_content_current_step,
m_navigate_back_action->enabled(),
m_navigate_forward_action->enabled(),
history_log_entries(m_session_history),
history_log_entries(web_content_known_entries, web_content_current_top_level_entry_index),
history_log_steps(web_content_known_used_steps, web_content_current_step_index));
}
LibWebView: Make loading an error page after a crash optional We won't need this in headless-browser (who isn't calling this helper yet).
2024-11-12 10:43:37 -03:00
void ViewImplementation::handle_web_content_process_crash(LoadErrorPage load_error_page)
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
{
LibWebView: Improve WebContent crash handling in headless mode This commit makes several improvements to crash handling for headless mode (used by test-web and other automated tools): 1. Always respawn WebContent after crashes, ignoring the crash count limit. The limit is meant for interactive use to prevent infinite crash loops; in headless mode, each test needs a working WebContent. 2. Skip the error page when respawning, as there's no UI to display it. 3. Suppress crash log messages that would corrupt live terminal output. These changes allow test-web to properly recover from WebContent crashes and continue running subsequent tests.
2026-01-12 20:15:04 -03:00
auto const headless_mode = Application::browser_options().headless_mode.has_value();
if (!headless_mode) {
dbgln("\033[31;1mWebContent process crashed!\033[0m Last page loaded: {}", m_url);
dbgln("Consider raising an issue at https://github.com/LadybirdBrowser/ladybird/issues/new/choose");
}
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
LibWebView: Don't re-create WebContent proceses when repeatedly crashing Serenity handles this in the SystemServer already, but the simplest place to put this logic is the ViewImplementation base class. This is trivial to see when running Ladybird without SERENTIY_SOURCE_DIR set, or set improperly.
2023-05-27 13:46:45 -03:00
++m_crash_count;
constexpr size_t max_reasonable_crash_count = 5U;
if (m_crash_count >= max_reasonable_crash_count) {
LibWebView: Improve WebContent crash handling in headless mode This commit makes several improvements to crash handling for headless mode (used by test-web and other automated tools): 1. Always respawn WebContent after crashes, ignoring the crash count limit. The limit is meant for interactive use to prevent infinite crash loops; in headless mode, each test needs a working WebContent. 2. Skip the error page when respawning, as there's no UI to display it. 3. Suppress crash log messages that would corrupt live terminal output. These changes allow test-web to properly recover from WebContent crashes and continue running subsequent tests.
2026-01-12 20:15:04 -03:00
if (!headless_mode) {
dbgln("WebContent has crashed {} times in quick succession! Not restarting...", m_crash_count);
m_repeated_crash_timer->stop();
return;
}
// In headless mode, always respawn - tests need a working WebContent for each test.
// Reset the crash count so we can continue running tests.
m_crash_count = 0;
LibWebView: Don't re-create WebContent proceses when repeatedly crashing Serenity handles this in the SystemServer already, but the simplest place to put this logic is the ViewImplementation base class. This is trivial to see when running Ladybird without SERENTIY_SOURCE_DIR set, or set improperly.
2023-05-27 13:46:45 -03:00
}
m_repeated_crash_timer->restart();
LibWebView: Improve WebContent crash handling in headless mode This commit makes several improvements to crash handling for headless mode (used by test-web and other automated tools): 1. Always respawn WebContent after crashes, ignoring the crash count limit. The limit is meant for interactive use to prevent infinite crash loops; in headless mode, each test needs a working WebContent. 2. Skip the error page when respawning, as there's no UI to display it. 3. Suppress crash log messages that would corrupt live terminal output. These changes allow test-web to properly recover from WebContent crashes and continue running subsequent tests.
2026-01-12 20:15:04 -03:00
// In headless mode, respawn WebContent but skip the error page.
if (headless_mode)
load_error_page = LoadErrorPage::No;
Ladybird: Add ability to create a tab without creating a new WebContent
2024-01-30 13:12:14 -03:00
initialize_client();
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
VERIFY(m_client_state.client);
// Don't keep a stale backup bitmap around.
Everywhere: Replace SharedBackingStore with Gfx::SharedImage Generalize the backing store sharing abstraction into SharedImage, which represents shared GPU memory independently of Skia and can be used to share memory between different processes or different GPU contexts.
2026-04-07 13:35:26 -03:00
m_backup_shared_image_buffer = nullptr;
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
if (should_manage_session_history_in_ui_process()) {
LibWebView: Keep UI history authoritative during races Keep UI process session history authoritative across overlapping fallback loads and traversals. WebContent can finish a superseded history load with a live document matching the UI seed URL while its local step, document state id, and Navigation API keys still describe a temporary partial list. Reconstruct the current entry around the UI-owned list in that case. This avoids making the UI process adopt WebContent's incomplete snapshot. Track UI-started fallback loads by URL so unrelated navigations cannot consume the pending seed state. Resolve deferred WebDriver completions through the view registry so callbacks queued before a process swap do not touch a destroyed view. Add WebDriver coverage that waits for explicit UI/WebContent history convergence after the relevant document events. The waits poll observable history state instead of depending on timing.
2026-06-16 08:03:40 -03:00
m_session_history_entry_url_loading_from_ui_process.clear();
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
prepare_to_seed_web_content_session_history_from_ui_process();
}
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
handle_resize();
LibWebView: Make loading an error page after a crash optional We won't need this in headless-browser (who isn't calling this helper yet).
2024-11-12 10:43:37 -03:00
if (load_error_page == LoadErrorPage::Yes) {
LibWebView+UI: Show an error page when we cannot sanitize a URL Previously, if search was disabled, entering non-URL text would just silently drop the search query (and on Qt, we would reload the current URL). We now detect that the query did not result in a navigation and load an error page instead, which directs the user to enable search.
2026-04-24 09:36:55 -03:00
auto escaped_url = escape_html_entities(m_url.serialize());
LibWebView: Make loading an error page after a crash optional We won't need this in headless-browser (who isn't calling this helper yet).
2024-11-12 10:43:37 -03:00
StringBuilder builder;
LibWeb+LibWebView: Preserve crashed page URLs on crash Load the browser-generated crash page as a synthetic response for the URL that was active when WebContent exited. This keeps the session history entry, response URL, and created Document aligned with the same navigation URL, so reload targets the original page without creating a local document for an HTTP(S) history entry. Suppress history metadata updates from the generated page and declare an inert rel=icon. Fallback favicon loading now follows the HTML condition that no link with the icon keyword exists, which avoids the credentialed /favicon.ico request from the crashed origin.
2026-05-20 11:42:08 -03:00
builder.appendff(ERROR_HTML_HEADER, NO_FALLBACK_FAVICON_LINK, CRASH_ERROR_SVG, "Ladybird flew off-course!"sv);
UI: Fix new error page
2025-03-26 18:46:48 -03:00
builder.appendff("<p>The web page <a href=\"{}\">{}</a> has crashed.<br><br>You can reload the page to try again.</p>", escaped_url, escaped_url);
LibWebView+UI: Show an error page when we cannot sanitize a URL Previously, if search was disabled, entering non-URL text would just silently drop the search query (and on Qt, we would reload the current URL). We now detect that the query did not result in a navigation and load an error page instead, which directs the user to enable search.
2026-04-24 09:36:55 -03:00
builder.append(ERROR_HTML_FOOTER);
LibWeb+LibWebView: Preserve crashed page URLs on crash Load the browser-generated crash page as a synthetic response for the URL that was active when WebContent exited. This keeps the session history entry, response URL, and created Document aligned with the same navigation URL, so reload targets the original page without creating a local document for an HTTP(S) history entry. Suppress history metadata updates from the generated page and declare an inert rel=icon. Fallback favicon loading now follows the HTML condition that no link with the icon keyword exists, which avoids the credentialed /favicon.ico request from the crashed origin.
2026-05-20 11:42:08 -03:00
load_crash_page_html(builder.string_view(), m_url);
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
} else if (should_manage_session_history_in_ui_process()) {
m_should_suppress_history_for_current_load = false;
m_should_suppress_history_for_next_load = false;
restore_current_session_history_entry_from_ui_process();
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
}
}
LibWebView: Add defaultZoomLevelFactor setting and necessary plumbing
2025-08-23 13:15:31 -03:00
void ViewImplementation::default_zoom_level_factor_changed()
{
LibWebView: Persist and restore zoom level per host Remember the zoom level for each host so that returning to a site restores the zoom the user previously chose, matching what other browsers have done for years. When the user zooms in, zooms out, or resets the zoom, the resulting level is written to Settings keyed by the current page's host. On navigation, when a view's URL host changes, the stored level for the new host is applied (or the global default if there is no override). Per-host zoom changes are broadcast through the SettingsObserver so that two tabs viewing the same host stay in sync as soon as the user adjusts zoom in either one. Zoom changes from within the page (such as internals.setBrowserZoom hook) and the WebContent restart path do not persist, only user-initiated zoom changes do.
2026-05-04 15:59:22 -03:00
apply_zoom_for_current_host();
}
void ViewImplementation::zoom_per_host_changed(StringView host)
{
if (current_host() != host)
return;
apply_zoom_for_current_host();
LibWebView: Add defaultZoomLevelFactor setting and necessary plumbing
2025-08-23 13:15:31 -03:00
}
LibWeb+LibWebView+UI: Migrate to LibWebView's language settings
2025-04-03 14:53:02 -03:00
void ViewImplementation::languages_changed()
{
auto const& languages = Application::settings().languages();
client().async_set_preferred_languages(page_id(), languages);
}
LibWeb+LibWebView+WebContent: Add a setting to control autoscrolling
2026-04-13 11:55:24 -03:00
void ViewImplementation::browsing_behavior_changed()
{
auto const& browsing_behavior = Application::settings().browsing_behavior();
client().async_set_browsing_behavior(page_id(), browsing_behavior);
}
LibWebView+WebContent+UI: Migrate to the new autoplay settings This removes the old autoplay allowlist file in favor of the new site setting. We still support the command-line flag to enable autoplay globally, as this is needed for WPT.
2025-03-29 09:19:00 -03:00
void ViewImplementation::autoplay_settings_changed()
{
auto const& autoplay_settings = Application::settings().autoplay_settings();
auto const& web_content_options = Application::web_content_options();
if (autoplay_settings.enabled_globally || web_content_options.enable_autoplay == EnableAutoplay::Yes)
client().async_set_autoplay_allowed_on_all_websites(page_id());
else
client().async_set_autoplay_allowlist(page_id(), autoplay_settings.site_filters.values());
}
LibWeb+LibWebView+WebContent: Replace DNT with GPC Global Privacy Control aims to be a replacement for Do Not Track. DNT ended up not being a great solution, as it wasn't enforced by law. This actually resulted in the DNT header serving as an extra fingerprinting data point. GPC is becoming enforced by law in USA states such as California and Colorado. CA is further working on a bill which requires that browsers implement such an opt-out preference signal (OOPS): https://cppa.ca.gov/announcements/2025/20250911.html This patch replaces DNT with GPC and hooks up the associated settings.
2025-04-02 10:30:34 -03:00
void ViewImplementation::global_privacy_control_changed()
LibWebView: Add do-not-track setting to about:settings
2025-04-02 10:47:44 -03:00
{
LibWeb+LibWebView+WebContent: Replace DNT with GPC Global Privacy Control aims to be a replacement for Do Not Track. DNT ended up not being a great solution, as it wasn't enforced by law. This actually resulted in the DNT header serving as an extra fingerprinting data point. GPC is becoming enforced by law in USA states such as California and Colorado. CA is further working on a bill which requires that browsers implement such an opt-out preference signal (OOPS): https://cppa.ca.gov/announcements/2025/20250911.html This patch replaces DNT with GPC and hooks up the associated settings.
2025-04-02 10:30:34 -03:00
auto global_privacy_control = Application::settings().global_privacy_control();
client().async_set_enable_global_privacy_control(page_id(), global_privacy_control == GlobalPrivacyControl::Yes);
LibWebView: Add do-not-track setting to about:settings
2025-04-02 10:47:44 -03:00
}
LibWebView: Integrate bookmarks into the application menus and settings This adds application menus and actions to display and manage bookmarks. These menus will be used by the UIs to generate concrete widgets.
2026-03-22 12:44:54 -03:00
void ViewImplementation::bookmarks_changed()
{
update_bookmark_action();
}
void ViewImplementation::update_bookmark_action()
{
Application::the().update_bookmark_action_for_current_web_view();
auto is_bookmarked = Application::bookmark_store().is_bookmarked(url());
m_toggle_bookmark_action->set_tooltip(is_bookmarked ? "Remove bookmark"sv : "Bookmark this page"sv);
m_toggle_bookmark_action->set_engaged(is_bookmarked);
}
LibWebView: Do not make the client bitmap shareable for screenshots Not sure what the issue is here, but it seems to cause very incorrect screenshots on macOS. In any case, it's wasted computation.
2025-05-29 14:30:45 -03:00
static ErrorOr<LexicalPath> save_screenshot(Gfx::Bitmap const* bitmap)
LibWebView+WebContent: Add a WebContent IPC to take DOM node screenshots
2023-12-06 13:51:44 -03:00
{
LibWebView: Do not make the client bitmap shareable for screenshots Not sure what the issue is here, but it seems to cause very incorrect screenshots on macOS. In any case, it's wasted computation.
2025-05-29 14:30:45 -03:00
if (!bitmap)
Everywhere: Convert from_string_view -> from_string_literal where static
2024-09-05 08:06:15 -03:00
return Error::from_string_literal("Failed to take a screenshot");
LibWebView+WebContent: Add a WebContent IPC to take DOM node screenshots
2023-12-06 13:51:44 -03:00
LibWebView: Add a `--screenshot-path` option This option saves screenshots to the given location.
2026-05-12 19:57:55 -03:00
auto path = TRY([] -> ErrorOr<LexicalPath> {
if (auto const& screenshot_path = Application::browser_options().screenshot_path; screenshot_path.has_value())
return LexicalPath { *screenshot_path };
auto file = AK::UnixDateTime::now().to_byte_string("screenshot-%Y-%m-%d-%H-%M-%S.png"sv);
return Application::the().path_for_downloaded_file(file);
}());
LibWebView+WebContent: Add a WebContent IPC to take DOM node screenshots
2023-12-06 13:51:44 -03:00
LibWebView: Do not make the client bitmap shareable for screenshots Not sure what the issue is here, but it seems to cause very incorrect screenshots on macOS. In any case, it's wasted computation.
2025-05-29 14:30:45 -03:00
auto encoded = TRY(Gfx::PNGWriter::encode(*bitmap));
LibWebView+WebContent: Add a WebContent IPC to take DOM node screenshots
2023-12-06 13:51:44 -03:00
LibJS+LibWebView+WebContent+Ladybird: Output GC-graph into a file Instead of displaying a massive JSON in stdout, it's more practical to save the GC-graph to a file.
2023-12-12 09:25:06 -03:00
auto dump_file = TRY(Core::File::open(path.string(), Core::File::OpenMode::Write));
TRY(dump_file->write_until_depleted(encoded));
LibWebView+WebContent: Add a WebContent IPC to take DOM node screenshots
2023-12-06 13:51:44 -03:00
LibWebView: Log the result of taking screenshots to Inspector's console It probably isn't obvious that screenshots are saved to the user's Downloads folder, so add a console message to inform them.
2023-12-09 18:57:57 -03:00
return path;
LibWebView+WebContent: Add a WebContent IPC to take DOM node screenshots
2023-12-06 13:51:44 -03:00
}
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 11:51:02 -03:00
NonnullRefPtr<Core::Promise<LexicalPath>> ViewImplementation::take_screenshot(ScreenshotType type)
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
{
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 11:51:02 -03:00
auto promise = Core::Promise<LexicalPath>::construct();
if (m_pending_screenshot) {
LibWeb: Fix typos - act II
2025-04-07 07:46:22 -03:00
// For simplicity, only allow taking one screenshot at a time for now. Revisit if we need
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 11:51:02 -03:00
// to allow spamming screenshot requests for some reason.
promise->reject(Error::from_string_literal("A screenshot request is already in progress"));
return promise;
}
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
switch (type) {
Everywhere: Replace SharedBackingStore with Gfx::SharedImage Generalize the backing store sharing abstraction into SharedImage, which represents shared GPU memory independently of Skia and can be used to share memory between different processes or different GPU contexts.
2026-04-07 13:35:26 -03:00
case ScreenshotType::Visible: {
Gfx::Bitmap const* visible_bitmap = nullptr;
if (m_client_state.has_usable_bitmap) {
VERIFY(m_client_state.front_bitmap.shared_image_buffer);
visible_bitmap = m_client_state.front_bitmap.shared_image_buffer->bitmap().ptr();
} else if (m_backup_shared_image_buffer) {
visible_bitmap = m_backup_shared_image_buffer->bitmap().ptr();
}
if (visible_bitmap) {
LibWebView: Do not make the client bitmap shareable for screenshots Not sure what the issue is here, but it seems to cause very incorrect screenshots on macOS. In any case, it's wasted computation.
2025-05-29 14:30:45 -03:00
if (auto result = save_screenshot(visible_bitmap); result.is_error())
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 11:51:02 -03:00
promise->reject(result.release_error());
else
promise->resolve(result.release_value());
}
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
break;
Everywhere: Replace SharedBackingStore with Gfx::SharedImage Generalize the backing store sharing abstraction into SharedImage, which represents shared GPU memory independently of Skia and can be used to share memory between different processes or different GPU contexts.
2026-04-07 13:35:26 -03:00
}
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 11:51:02 -03:00
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
case ScreenshotType::Full:
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 11:51:02 -03:00
m_pending_screenshot = promise;
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_take_document_screenshot(page_id());
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
break;
}
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 11:51:02 -03:00
return promise;
}
LibWeb: Make DOM Node unique IDs strongly typed (and 64 bit) This is strictly nicer than passing them around as i32 everywhere, and by switching to i64 as the underlying type, ID allocation becomes as simple as incrementing an integer.
2024-10-20 05:37:44 -03:00
NonnullRefPtr<Core::Promise<LexicalPath>> ViewImplementation::take_dom_node_screenshot(Web::UniqueNodeID node_id)
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 11:51:02 -03:00
{
auto promise = Core::Promise<LexicalPath>::construct();
if (m_pending_screenshot) {
LibWeb: Fix typos - act II
2025-04-07 07:46:22 -03:00
// For simplicity, only allow taking one screenshot at a time for now. Revisit if we need
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 11:51:02 -03:00
// to allow spamming screenshot requests for some reason.
promise->reject(Error::from_string_literal("A screenshot request is already in progress"));
return promise;
}
m_pending_screenshot = promise;
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-02 22:00:48 -03:00
client().async_take_dom_node_screenshot(page_id(), node_id);
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 11:51:02 -03:00
return promise;
LibWebView+WebContent: Add a WebContent IPC to take DOM node screenshots
2023-12-06 13:51:44 -03:00
}
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 11:51:02 -03:00
void ViewImplementation::did_receive_screenshot(Badge<WebContentClient>, Gfx::ShareableBitmap const& screenshot)
LibWebView+WebContent: Add a WebContent IPC to take DOM node screenshots
2023-12-06 13:51:44 -03:00
{
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 11:51:02 -03:00
VERIFY(m_pending_screenshot);
LibWebView: Do not make the client bitmap shareable for screenshots Not sure what the issue is here, but it seems to cause very incorrect screenshots on macOS. In any case, it's wasted computation.
2025-05-29 14:30:45 -03:00
if (auto result = save_screenshot(screenshot.bitmap()); result.is_error())
Ladybird+LibWebView+WebContent: Make the screenshot IPCs async These IPCs are different than other IPCs in that we can't just set up a callback function to be invoked when WebContent sends us the screenshot data. There are multiple places that would set that callback, and they would step on each other's toes. Instead, the screenshot APIs on ViewImplementation now return a Promise which callers can interact with to receive the screenshot (or an error).
2023-12-31 11:51:02 -03:00
m_pending_screenshot->reject(result.release_error());
else
m_pending_screenshot->resolve(result.release_value());
m_pending_screenshot = nullptr;
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 10:53:13 -03:00
}
LibWebView+WebContent+headless-browser: Make the page info IPCs async The IPCs to request a page's text, layout tree, etc. are currently all synchronous. This can result in a deadlock when WebContent also makes a synchronous IPC call, as both ends will be waiting on each other. This replaces the page info IPCs with a single, asynchronous IPC. This new IPC is promise-based, much like our screenshot IPC.
2024-09-19 11:40:00 -03:00
NonnullRefPtr<Core::Promise<String>> ViewImplementation::request_internal_page_info(PageInfoType type)
{
auto promise = Core::Promise<String>::construct();
if (m_pending_info_request) {
LibWeb: Fix typos - act II
2025-04-07 07:46:22 -03:00
// For simplicity, only allow one info request at a time for now.
LibWebView+WebContent+headless-browser: Make the page info IPCs async The IPCs to request a page's text, layout tree, etc. are currently all synchronous. This can result in a deadlock when WebContent also makes a synchronous IPC call, as both ends will be waiting on each other. This replaces the page info IPCs with a single, asynchronous IPC. This new IPC is promise-based, much like our screenshot IPC.
2024-09-19 11:40:00 -03:00
promise->reject(Error::from_string_literal("A page info request is already in progress"));
return promise;
}
m_pending_info_request = promise;
client().async_request_internal_page_info(page_id(), type);
return promise;
}
WebContent+LibWebView: Send GC graphs etc over IPC as shared memory These can get very large, exceeding the new IPC message size limits. Instead of serializing them into messages (which was silly anyway) we now send them as Core::AnonymousBuffer which uses shared memory.
2026-02-01 16:18:43 -03:00
void ViewImplementation::did_receive_internal_page_info(Badge<WebContentClient>, PageInfoType, Optional<Core::AnonymousBuffer> const& info)
LibWebView+WebContent+headless-browser: Make the page info IPCs async The IPCs to request a page's text, layout tree, etc. are currently all synchronous. This can result in a deadlock when WebContent also makes a synchronous IPC call, as both ends will be waiting on each other. This replaces the page info IPCs with a single, asynchronous IPC. This new IPC is promise-based, much like our screenshot IPC.
2024-09-19 11:40:00 -03:00
{
VERIFY(m_pending_info_request);
WebContent+LibWebView: Send GC graphs etc over IPC as shared memory These can get very large, exceeding the new IPC message size limits. Instead of serializing them into messages (which was silly anyway) we now send them as Core::AnonymousBuffer which uses shared memory.
2026-02-01 16:18:43 -03:00
String info_string;
if (!info.has_value()) {
info_string = "(no page)"_string;
} else {
info_string = MUST(String::from_utf8(info->bytes()));
}
m_pending_info_request->resolve(move(info_string));
LibWebView+WebContent+headless-browser: Make the page info IPCs async The IPCs to request a page's text, layout tree, etc. are currently all synchronous. This can result in a deadlock when WebContent also makes a synchronous IPC call, as both ends will be waiting on each other. This replaces the page info IPCs with a single, asynchronous IPC. This new IPC is promise-based, much like our screenshot IPC.
2024-09-19 11:40:00 -03:00
m_pending_info_request = nullptr;
}
LibJS+LibWebView+WebContent+Ladybird: Output GC-graph into a file Instead of displaying a massive JSON in stdout, it's more practical to save the GC-graph to a file.
2023-12-12 09:25:06 -03:00
ErrorOr<LexicalPath> ViewImplementation::dump_gc_graph()
{
LibWebView+WebContent+headless-browser: Make the page info IPCs async The IPCs to request a page's text, layout tree, etc. are currently all synchronous. This can result in a deadlock when WebContent also makes a synchronous IPC call, as both ends will be waiting on each other. This replaces the page info IPCs with a single, asynchronous IPC. This new IPC is promise-based, much like our screenshot IPC.
2024-09-19 11:40:00 -03:00
auto promise = request_internal_page_info(PageInfoType::GCGraph);
auto gc_graph_json = TRY(promise->await());
LibJS+LibWebView+WebContent+Ladybird: Output GC-graph into a file Instead of displaying a massive JSON in stdout, it's more practical to save the GC-graph to a file.
2023-12-12 09:25:06 -03:00
LexicalPath path { Core::StandardPaths::tempfile_directory() };
LibWebView+test-web: Print heap explorer URL after dumping GC graph When dumping a GC graph, we now write the output as a .js file containing `var GC_GRAPH_DUMP = <json>;` instead of raw JSON. This allows gc-heap-explorer.html to load the dump via a dynamically created <script> element, avoiding CORS restrictions that prevent file:// pages from fetching other file:// URLs. After dumping, both the browser and test-web print a clickable file:// URL that opens the heap explorer with the dump pre-loaded. The heap explorer's drag-and-drop file picker also accepts both the new .js format and plain .json files.
2026-02-01 16:52:16 -03:00
path = path.append(TRY(AK::UnixDateTime::now().to_string("gc-graph-%Y-%m-%d-%H-%M-%S.js"sv)));
LibJS+LibWebView+WebContent+Ladybird: Output GC-graph into a file Instead of displaying a massive JSON in stdout, it's more practical to save the GC-graph to a file.
2023-12-12 09:25:06 -03:00
LibWebView+test-web: Print heap explorer URL after dumping GC graph When dumping a GC graph, we now write the output as a .js file containing `var GC_GRAPH_DUMP = <json>;` instead of raw JSON. This allows gc-heap-explorer.html to load the dump via a dynamically created <script> element, avoiding CORS restrictions that prevent file:// pages from fetching other file:// URLs. After dumping, both the browser and test-web print a clickable file:// URL that opens the heap explorer with the dump pre-loaded. The heap explorer's drag-and-drop file picker also accepts both the new .js format and plain .json files.
2026-02-01 16:52:16 -03:00
// Write as a .js file so gc-heap-explorer.html can load it via <script> tag (avoiding CORS issues with file:// URLs)
LibWebView+WebContent+headless-browser: Make the page info IPCs async The IPCs to request a page's text, layout tree, etc. are currently all synchronous. This can result in a deadlock when WebContent also makes a synchronous IPC call, as both ends will be waiting on each other. This replaces the page info IPCs with a single, asynchronous IPC. This new IPC is promise-based, much like our screenshot IPC.
2024-09-19 11:40:00 -03:00
auto dump_file = TRY(Core::File::open(path.string(), Core::File::OpenMode::Write));
LibWebView+test-web: Print heap explorer URL after dumping GC graph When dumping a GC graph, we now write the output as a .js file containing `var GC_GRAPH_DUMP = <json>;` instead of raw JSON. This allows gc-heap-explorer.html to load the dump via a dynamically created <script> element, avoiding CORS restrictions that prevent file:// pages from fetching other file:// URLs. After dumping, both the browser and test-web print a clickable file:// URL that opens the heap explorer with the dump pre-loaded. The heap explorer's drag-and-drop file picker also accepts both the new .js format and plain .json files.
2026-02-01 16:52:16 -03:00
TRY(dump_file->write_until_depleted("var GC_GRAPH_DUMP = "sv.bytes()));
LibWebView+WebContent+headless-browser: Make the page info IPCs async The IPCs to request a page's text, layout tree, etc. are currently all synchronous. This can result in a deadlock when WebContent also makes a synchronous IPC call, as both ends will be waiting on each other. This replaces the page info IPCs with a single, asynchronous IPC. This new IPC is promise-based, much like our screenshot IPC.
2024-09-19 11:40:00 -03:00
TRY(dump_file->write_until_depleted(gc_graph_json.bytes()));
LibWebView+test-web: Print heap explorer URL after dumping GC graph When dumping a GC graph, we now write the output as a .js file containing `var GC_GRAPH_DUMP = <json>;` instead of raw JSON. This allows gc-heap-explorer.html to load the dump via a dynamically created <script> element, avoiding CORS restrictions that prevent file:// pages from fetching other file:// URLs. After dumping, both the browser and test-web print a clickable file:// URL that opens the heap explorer with the dump pre-loaded. The heap explorer's drag-and-drop file picker also accepts both the new .js format and plain .json files.
2026-02-01 16:52:16 -03:00
TRY(dump_file->write_until_depleted(";\n"sv.bytes()));
LibJS+LibWebView+WebContent+Ladybird: Output GC-graph into a file Instead of displaying a massive JSON in stdout, it's more practical to save the GC-graph to a file.
2023-12-12 09:25:06 -03:00
return path;
}
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
void ViewImplementation::set_user_style_sheet(String const& source)
LibWebView: Allow using native/user style sheets on Lagom Move the methods to set the native/user style sheets to the base ViewImplementation class. We must also generate the native style sheet explicitly for now, as LibWebView on Lagom isn't able to include the main LibWebView CMakeLists.txt file yet.
2023-08-26 14:34:59 -03:00
{
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
client().async_set_user_style(page_id(), source);
LibWebView: Allow using native/user style sheets on Lagom Move the methods to set the native/user style sheets to the base ViewImplementation class. We must also generate the native style sheet explicitly for now, as LibWebView on Lagom isn't able to include the main LibWebView CMakeLists.txt file yet.
2023-08-26 14:34:59 -03:00
}
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
void ViewImplementation::initialize_context_menus()
{
auto& application = Application::the();
m_navigate_back_action = Action::create("Go Back"sv, ActionID::NavigateBack, [this]() {
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
(void)traverse_the_history_by_delta(-1);
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
});
m_navigate_forward_action = Action::create("Go Forward"sv, ActionID::NavigateForward, [this]() {
LibWebView: Keep browser history in the UI process Use the LibWebView history mirror to preserve traversable session history across WebContent process swaps. WebContent reports snapshots to the UI process, and new renderers can be seeded from the mirror. Browser back and forward now resolve through the UI-owned used history steps. WebContent still runs the spec traversal path when the current renderer has enough matching state to do so. Handle canceled and no-op UI navigations without leaving speculative history entries or pending WebDriver waits behind. Preserve traversal precheck state across synchronous IPC shutdown, and avoid overwriting a restored target entry's persisted scroll state before the document has adopted that entry.
2026-06-13 11:06:49 -03:00
(void)traverse_the_history_by_delta(+1);
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
});
m_navigate_back_action->set_enabled(false);
m_navigate_forward_action->set_enabled(false);
LibWebView: Integrate bookmarks into the application menus and settings This adds application menus and actions to display and manage bookmarks. These menus will be used by the UIs to generate concrete widgets.
2026-03-22 12:44:54 -03:00
m_toggle_bookmark_action = Action::create("Toggle Bookmark"sv, ActionID::ToggleBookmarkViaToolbar, [this]() {
auto& bookmark_store = Application::bookmark_store();
if (auto bookmark = bookmark_store.find_bookmark_by_url(url()); bookmark.has_value())
bookmark_store.remove_item(bookmark->id);
else
bookmark_store.add_bookmark(url(), title().to_utf8(), favicon_base64_png());
});
update_bookmark_action();
LibWebView+UI: Generate the zoom menu
2025-09-10 08:23:15 -03:00
m_reset_zoom_action = Action::create("100%"sv, ActionID::ResetZoomViaToolbar, [this]() {
reset_zoom();
});
m_reset_zoom_action->set_tooltip("Reset zoom level"sv);
m_reset_zoom_action->set_visible(false);
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
m_search_selected_text_action = Action::create("Search Selected Text"sv, ActionID::SearchSelectedText, [this]() {
auto const& search_engine = Application::settings().search_engine();
if (!search_engine.has_value())
return;
auto url_string = search_engine->format_search_query_for_navigation(*m_search_text);
auto url = URL::Parser::basic_parse(url_string);
VERIFY(url.has_value());
LibWebView+UI: Add an Application method to open a URL in a new tab This lets us avoid each UI needing to handle link clicks directly, and lets actions stored in LibWebView avoid awkwardly going through the link click callbacks to open URLs.
2025-09-13 10:08:24 -03:00
Application::the().open_url_in_new_tab(*url, Web::HTML::ActivateTab::Yes);
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
});
m_search_selected_text_action->set_visible(false);
auto take_and_save_screenshot = [this](auto type) {
take_screenshot(type)
->when_resolved([](auto const& path) {
Application::the().display_download_confirmation_dialog("Screenshot"sv, path);
})
.when_rejected([](auto const& error) {
if (error.is_errno() && error.code() == ECANCELED)
return;
auto error_message = MUST(String::formatted("{}", error));
Application::the().display_error_dialog(error_message);
});
};
m_take_visible_screenshot_action = Action::create("Take Visible Screenshot"sv, ActionID::TakeVisibleScreenshot, [take_and_save_screenshot]() {
take_and_save_screenshot(ScreenshotType::Visible);
});
m_take_full_screenshot_action = Action::create("Take Full Screenshot"sv, ActionID::TakeFullScreenshot, [take_and_save_screenshot]() {
take_and_save_screenshot(ScreenshotType::Full);
});
m_open_in_new_tab_action = Action::create("Open in New Tab"sv, ActionID::OpenInNewTab, [this]() {
LibWebView+UI: Add an Application method to open a URL in a new tab This lets us avoid each UI needing to handle link clicks directly, and lets actions stored in LibWebView avoid awkwardly going through the link click callbacks to open URLs.
2025-09-13 10:08:24 -03:00
Application::the().open_url_in_new_tab(m_context_menu_url, Web::HTML::ActivateTab::No);
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
});
UI+LibWebView: Implement "Open Link in New Window"
2026-02-17 16:23:45 -03:00
m_open_in_new_window_action = Action::create("Open in New Window"sv, ActionID::OpenInNewWindow, [this]() {
Application::the().open_url_in_new_window(m_context_menu_url);
});
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
m_copy_url_action = Action::create("Copy URL"sv, ActionID::CopyURL, [this]() {
LibWebView+UI: Move clipboard handling from the WebView to the App Clipboard handling largely has nothing to do with the individual web views. Rather, we interact with the system clipboard at the application level. So let's move these implementations to the Application.
2025-09-18 09:16:36 -03:00
Application::the().insert_clipboard_entry({ url_text_to_copy(m_context_menu_url), "text/plain"_string });
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
});
m_open_image_action = Action::create("Open Image"sv, ActionID::OpenImage, [this]() {
LibWebView+UI: Add an Application method to open a URL in a new tab This lets us avoid each UI needing to handle link clicks directly, and lets actions stored in LibWebView avoid awkwardly going through the link click callbacks to open URLs.
2025-09-13 10:08:24 -03:00
load(m_context_menu_url);
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
});
LibWebView+UI: Add a context menu item to download images This introduces a simple FileDownloader to download files in the UI process from RequestServer. We use this to download the context menu image - this download is likely to hit the disk cache.
2026-02-03 10:00:15 -03:00
m_save_image_action = Action::create("Save Image As..."sv, ActionID::SaveImage, [this]() {
auto download_path = Application::the().path_for_downloaded_file(m_context_menu_url.basename());
if (download_path.is_error())
return;
Application::the().file_downloader().download_file(m_context_menu_url, download_path.release_value());
});
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
m_copy_image_action = Action::create("Copy Image"sv, ActionID::CopyImage, [this]() {
if (!m_image_context_menu_bitmap.has_value())
return;
auto bitmap = m_image_context_menu_bitmap.release_value();
if (!bitmap.is_valid())
return;
auto encoded = Gfx::PNGWriter::encode(*bitmap.bitmap());
if (encoded.is_error())
return;
LibWebView+UI: Move clipboard handling from the WebView to the App Clipboard handling largely has nothing to do with the individual web views. Rather, we interact with the system clipboard at the application level. So let's move these implementations to the Application.
2025-09-18 09:16:36 -03:00
Application::the().insert_clipboard_entry({ ByteString { encoded.value().bytes() }, "image/png"_string });
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
});
m_open_audio_action = Action::create("Open Audio"sv, ActionID::OpenAudio, [this]() {
LibWebView+UI: Add an Application method to open a URL in a new tab This lets us avoid each UI needing to handle link clicks directly, and lets actions stored in LibWebView avoid awkwardly going through the link click callbacks to open URLs.
2025-09-13 10:08:24 -03:00
load(m_context_menu_url);
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
});
m_open_video_action = Action::create("Open Video"sv, ActionID::OpenVideo, [this]() {
LibWebView+UI: Add an Application method to open a URL in a new tab This lets us avoid each UI needing to handle link clicks directly, and lets actions stored in LibWebView avoid awkwardly going through the link click callbacks to open URLs.
2025-09-13 10:08:24 -03:00
load(m_context_menu_url);
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
});
m_media_play_action = Action::create("Play"sv, ActionID::PlayMedia, [this]() {
client().async_toggle_media_play_state(page_id());
});
m_media_pause_action = Action::create("Pause"sv, ActionID::PauseMedia, [this]() {
client().async_toggle_media_play_state(page_id());
});
m_media_mute_action = Action::create("Mute"sv, ActionID::MuteMedia, [this]() {
client().async_toggle_media_mute_state(page_id());
});
m_media_unmute_action = Action::create("Unmute"sv, ActionID::UnmuteMedia, [this]() {
client().async_toggle_media_mute_state(page_id());
});
LibWebView+UI/AppKit: Display icons in the macOS UI on Tahoe On macOS Tahoe, it is now recommended to show menu item icons. We use system symbols for this now. Symbols do not have constant variable names and must be found via the SF Symbols app. The symbols chosen here were to match Safari as close as possible.
2025-09-16 13:55:37 -03:00
m_media_show_controls_action = Action::create("Show Controls"sv, ActionID::ShowControls, [this]() {
client().async_toggle_media_controls_state(page_id());
});
m_media_hide_controls_action = Action::create("Hide Controls"sv, ActionID::HideControls, [this]() {
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
client().async_toggle_media_controls_state(page_id());
});
m_media_loop_action = Action::create_checkable("Loop"sv, ActionID::ToggleMediaLoopState, [this]() {
client().async_toggle_media_loop_state(page_id());
});
LibWeb+LibWebView+UI: Add a context menu item to toggle fullscreen state
2026-02-28 11:36:32 -03:00
m_media_enter_fullscreen_action = Action::create("Full Screen"sv, ActionID::EnterFullscreen, [this]() {
client().async_toggle_media_fullscreen_state(page_id());
});
m_media_exit_fullscreen_action = Action::create("Exit Full Screen"sv, ActionID::ExitFullscreen, [this]() {
client().async_toggle_media_fullscreen_state(page_id());
});
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
m_page_context_menu = Menu::create("Page Context Menu"sv);
m_page_context_menu->add_action(*m_navigate_back_action);
m_page_context_menu->add_action(*m_navigate_forward_action);
m_page_context_menu->add_action(application.reload_action());
m_page_context_menu->add_separator();
LibWeb+LibWebView+WebContent+UI: Add an action to cut text
2026-05-06 13:00:59 -03:00
m_page_context_menu->add_action(application.cut_selection_action());
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
m_page_context_menu->add_action(application.copy_selection_action());
m_page_context_menu->add_action(application.paste_action());
m_page_context_menu->add_action(application.select_all_action());
m_page_context_menu->add_separator();
m_page_context_menu->add_action(*m_search_selected_text_action);
m_page_context_menu->add_separator();
m_page_context_menu->add_action(*m_take_visible_screenshot_action);
m_page_context_menu->add_action(*m_take_full_screenshot_action);
m_page_context_menu->add_separator();
m_page_context_menu->add_action(application.view_source_action());
m_link_context_menu = Menu::create("Link Context Menu"sv);
m_link_context_menu->add_action(*m_open_in_new_tab_action);
UI+LibWebView: Implement "Open Link in New Window"
2026-02-17 16:23:45 -03:00
m_link_context_menu->add_action(*m_open_in_new_window_action);
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
m_link_context_menu->add_action(*m_copy_url_action);
m_image_context_menu = Menu::create("Image Context Menu"sv);
m_image_context_menu->add_action(*m_open_image_action);
m_image_context_menu->add_action(*m_open_in_new_tab_action);
m_image_context_menu->add_separator();
LibWebView+UI: Add a context menu item to download images This introduces a simple FileDownloader to download files in the UI process from RequestServer. We use this to download the context menu image - this download is likely to hit the disk cache.
2026-02-03 10:00:15 -03:00
m_image_context_menu->add_action(*m_save_image_action);
m_image_context_menu->add_separator();
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
m_image_context_menu->add_action(*m_copy_image_action);
m_image_context_menu->add_action(*m_copy_url_action);
m_media_context_menu = Menu::create("Media Context Menu"sv);
m_media_context_menu->add_action(*m_media_play_action);
m_media_context_menu->add_action(*m_media_pause_action);
m_media_context_menu->add_action(*m_media_mute_action);
m_media_context_menu->add_action(*m_media_unmute_action);
LibWebView+UI/AppKit: Display icons in the macOS UI on Tahoe On macOS Tahoe, it is now recommended to show menu item icons. We use system symbols for this now. Symbols do not have constant variable names and must be found via the SF Symbols app. The symbols chosen here were to match Safari as close as possible.
2025-09-16 13:55:37 -03:00
m_media_context_menu->add_action(*m_media_show_controls_action);
m_media_context_menu->add_action(*m_media_hide_controls_action);
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
m_media_context_menu->add_action(*m_media_loop_action);
LibWeb+LibWebView+UI: Add a context menu item to toggle fullscreen state
2026-02-28 11:36:32 -03:00
m_media_context_menu->add_action(*m_media_enter_fullscreen_action);
m_media_context_menu->add_action(*m_media_exit_fullscreen_action);
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
m_media_context_menu->add_separator();
m_media_context_menu->add_action(*m_open_audio_action);
m_media_context_menu->add_action(*m_open_video_action);
m_media_context_menu->add_action(*m_open_in_new_tab_action);
m_media_context_menu->add_separator();
m_media_context_menu->add_action(*m_copy_url_action);
}
LibWeb+LibWebView+WebContent+UI: Add an action to cut text
2026-05-06 13:00:59 -03:00
void ViewImplementation::did_request_page_context_menu(Badge<WebContentClient>, Gfx::IntPoint content_position, Web::ContextMenuForInputEventsTarget for_input_events_target)
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
{
LibWeb+LibWebView+WebContent+UI: Add an action to cut text
2026-05-06 13:00:59 -03:00
auto& cut_selection_action = Application::the().cut_selection_action();
cut_selection_action.set_visible(for_input_events_target == Web::ContextMenuForInputEventsTarget::Yes);
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
auto const& search_engine = Application::settings().search_engine();
LibWeb+LibWebView+WebContent+UI: Add an action to cut text
2026-05-06 13:00:59 -03:00
m_search_text = search_engine.has_value() ? selected_text_with_whitespace_collapsed() : OptionalNone {};
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
LibWeb+LibWebView+WebContent+UI: Add an action to cut text
2026-05-06 13:00:59 -03:00
ScopeGuard guard { [&]() {
cut_selection_action.set_visible(true);
m_search_text.clear();
} };
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
if (m_search_text.has_value()) {
m_search_selected_text_action->set_text(search_engine->format_search_query_for_display(*m_search_text));
m_search_selected_text_action->set_visible(true);
} else {
m_search_selected_text_action->set_visible(false);
}
if (m_page_context_menu->on_activation)
m_page_context_menu->on_activation(to_widget_position(content_position));
}
void ViewImplementation::did_request_link_context_menu(Badge<WebContentClient>, Gfx::IntPoint content_position, URL::URL url)
{
m_context_menu_url = move(url);
m_open_in_new_tab_action->set_text("Open in New Tab"sv);
switch (url_type(m_context_menu_url)) {
case URLType::Email:
m_copy_url_action->set_text("Copy Email Address"sv);
break;
case URLType::Telephone:
m_copy_url_action->set_text("Copy Phone Number"sv);
break;
case URLType::Other:
m_copy_url_action->set_text("Copy Link Address"sv);
break;
}
if (m_link_context_menu->on_activation)
m_link_context_menu->on_activation(to_widget_position(content_position));
}
void ViewImplementation::did_request_image_context_menu(Badge<WebContentClient>, Gfx::IntPoint content_position, URL::URL url, Optional<Gfx::ShareableBitmap> bitmap)
{
m_context_menu_url = move(url);
m_image_context_menu_bitmap = move(bitmap);
m_open_in_new_tab_action->set_text("Open Image in New Tab"sv);
m_copy_url_action->set_text("Copy Image URL"sv);
m_copy_image_action->set_enabled(m_image_context_menu_bitmap.has_value());
if (m_image_context_menu->on_activation)
m_image_context_menu->on_activation(to_widget_position(content_position));
}
void ViewImplementation::did_request_media_context_menu(Badge<WebContentClient>, Gfx::IntPoint content_position, Web::Page::MediaContextMenu menu)
{
m_context_menu_url = move(menu.media_url);
m_open_in_new_tab_action->set_text(menu.is_video ? "Open Video in New Tab"sv : "Open Audio in new Tab"sv);
m_copy_url_action->set_text(menu.is_video ? "Copy Video URL"sv : "Copy Audio URL"sv);
m_open_audio_action->set_visible(!menu.is_video);
m_open_video_action->set_visible(menu.is_video);
m_media_play_action->set_visible(!menu.is_playing);
m_media_pause_action->set_visible(menu.is_playing);
m_media_mute_action->set_visible(!menu.is_muted);
m_media_unmute_action->set_visible(menu.is_muted);
LibWebView+UI/AppKit: Display icons in the macOS UI on Tahoe On macOS Tahoe, it is now recommended to show menu item icons. We use system symbols for this now. Symbols do not have constant variable names and must be found via the SF Symbols app. The symbols chosen here were to match Safari as close as possible.
2025-09-16 13:55:37 -03:00
m_media_show_controls_action->set_visible(!menu.has_user_agent_controls);
m_media_hide_controls_action->set_visible(menu.has_user_agent_controls);
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
m_media_loop_action->set_checked(menu.is_looping);
LibWeb+LibWebView+UI: Add a context menu item to toggle fullscreen state
2026-02-28 11:36:32 -03:00
m_media_enter_fullscreen_action->set_visible(menu.is_video && !menu.is_fullscreen);
m_media_exit_fullscreen_action->set_visible(menu.is_video && menu.is_fullscreen);
LibWebView+UI: Generate application context menus This migrates all duplicated context menus from the UIs to LibWebView. The context menu actions are now largely handled directly in LibWebView, with some UI-specific callbacks added to display e.g. confirmation dialogs. Actions that only ever apply to a specific web view are stored on the ViewImplementation itself. Actions that need to be dynamically applied to the active web view are stored on the Application.
2025-09-01 09:20:14 -03:00
if (m_media_context_menu->on_activation)
m_media_context_menu->on_activation(to_widget_position(content_position));
}
LibDevTools: Send navigation events to Firefox DevTools When a page navigates, send document-event resources with "will-navigate" and tabNavigated messages so Firefox DevTools can follow along and clear the Network panel appropriately.
2026-01-14 15:03:16 -03:00
u64 ViewImplementation::add_navigation_listener(NavigationListener listener)
{
auto id = m_next_navigation_listener_id++;
m_navigation_listeners.set(id, move(listener));
return id;
}
void ViewImplementation::remove_navigation_listener(u64 listener_id)
{
m_navigation_listeners.remove(listener_id);
}
WebContent+LibWebView: Add endpoint to request top level closure This will allow the UI to request WebContent to properly close the top level traversable when closing a tab. For example, this allows the site to ask if the user is sure they want to leave, closes WebSocket connections and more.
2025-11-07 12:35:05 -03:00
void ViewImplementation::request_close()
{
LibWebView: Fast-close pages without beforeunload prompts Track whether WebContent still needs a beforeunload check and let the frontends immediately remove a tab or window when no prompt can be shown. WebContent still receives the close request so pagehide, unload, and cleanup steps can run. When the visible view is removed immediately, keep detached ownership of the WebContent page until it reports that the top-level traversable closed. If no acknowledgement arrives, release detached ownership and ask ProcessManager to shut down the unused WebContent process.
2026-05-26 13:03:07 -03:00
if (needs_beforeunload_check()) {
client().async_request_close(page_id());
return;
}
client().request_close(page_id());
}
Function<void()> ViewImplementation::prepare_for_immediate_close()
{
VERIFY(!needs_beforeunload_check());
auto client = m_client_state.client;
auto page_id = m_client_state.page_index;
client->prepare_for_detached_close(page_id);
return [client = move(client), page_id] {
client->async_request_close(page_id);
};
WebContent+LibWebView: Add endpoint to request top level closure This will allow the UI to request WebContent to properly close the top level traversable when closing a tab. For example, this allows the site to ask if the user is sure they want to leave, closes WebSocket connections and more.
2025-11-07 12:35:05 -03:00
}
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 16:27:17 -03:00
}
Reference in a new issue Copy permalink