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

649 lines
31 KiB
C
Raw Permalink Normal View History

LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 09:32:17 -03:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 08:19:50 -03:00
* Copyright (c) 2022, Andreas Kling <andreas@ladybird.org>
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
* Copyright (c) 2023, Linus Groh <linusg@serenityos.org>
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 09:32:17 -03:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Forward.h>
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 13:37:31 -03:00
#include <AK/Function.h>
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
#include <AK/JsonArray.h>
LibWebView: Parse inspector-related JSON strings sooner We currently receive serialized JSON values over IPC and forward them to them WebView callbacks, leaving it to the implementations of those callbacks to parse the strings as JSON objects. This patch hoists that parsing up to WebContentClient as soon as the IPC message is received. This is to reduce the work needed for secondary implementations of these callbacks (i.e. our Firefox DevTools server).
2025-02-21 14:39:43 -03:00
#include <AK/JsonObject.h>
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
#include <AK/JsonValue.h>
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
#include <AK/LexicalPath.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 <AK/OwnPtr.h>
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
#include <AK/Queue.h>
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
#include <AK/String.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/Types.h>
LibWeb+LibWebView+WebContent+UI: Port the document title to UTF-16
2025-07-28 17:51:01 -03:00
#include <AK/Utf16String.h>
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
#include <LibCore/AnonymousBuffer.h>
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
#include <LibCore/Forward.h>
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
#include <LibCore/Promise.h>
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
#include <LibCore/SharedVersion.h>
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
#include <LibDevTools/DevToolsDelegate.h>
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
#include <LibGfx/Color.h>
LibGfx: Add ImageCursor type and Cursor variant Besides standard cursors, we also need to support custom images. For now, everything still uses StandardCursor.
2025-02-17 12:49:05 -03:00
#include <LibGfx/Cursor.h>
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 09:32:17 -03:00
#include <LibGfx/Forward.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/SharedImage.h>
#include <LibGfx/SharedImageBuffer.h>
LibDevTools: Add Firefox DevTools network monitoring support Hook ResourceLoader to emit network request lifecycle events through IPC to the UI process, where FrameActor creates NetworkEventActor instances that serialize requests using Firefox's Remote Debug Protocol. The Network panel now shows requests with method, URL, status, MIME type, size, and timing information. Several features remain stubbed (POST data, response content, cause detection) marked with FIXMEs.
2026-01-14 14:43:48 -03:00
#include <LibHTTP/Header.h>
#include <LibRequests/Forward.h>
#include <LibRequests/NetworkError.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/Bindings/Navigation.h>
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 09:32:17 -03:00
#include <LibWeb/Forward.h>
WebContent+Everywhere: Add an option to not activate new tabs over IPC WebDriver, for example, will want to create new tabs without activating them.
2023-03-20 19:39:20 -03:00
#include <LibWeb/HTML/ActivateTab.h>
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
#include <LibWeb/HTML/AudioPlayState.h>
LibWeb: Allow input color to give continuous updates
2023-12-11 02:53:10 -03:00
#include <LibWeb/HTML/ColorPickerUpdateState.h>
Ladybird+LibWeb+WebContent: Parse the <input type=file> accept attribute This parses the accept attribute value for file input types and passes it along to the browser chromes.
2024-03-14 13:26:00 -03:00
#include <LibWeb/HTML/FileFilter.h>
Ladybird+LibWeb: Add basic select element support
2023-12-07 11:53:49 -03:00
#include <LibWeb/HTML/SelectItem.h>
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
#include <LibWeb/Page/EventResult.h>
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
#include <LibWeb/Page/InputEvent.h>
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
#include <LibWeb/Page/ViewportIsFullscreen.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/Response.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>
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
#include <LibWebView/DOMNodeProperties.h>
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 09:32:17 -03:00
#include <LibWebView/Forward.h>
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
#include <LibWebView/PageInfo.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/SessionHistory.h>
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
#include <LibWebView/Settings.h>
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
#include <LibWebView/StorageSetResult.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/WebContentClient.h>
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 09:32:17 -03:00
namespace WebView {
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
class WEBVIEW_API ViewImplementation
: public SettingsObserver
, public BookmarkStoreObserver {
LibWebView: Notify all views when shared WebContent crashes When multiple views share a WebContent process (e.g. parent and child views created via window.open()), we need to notify ALL of them when the process crashes, not just one. Previously, each view would overwrite the single crash callback on WebContentClient, so only the last view to initialize would be notified. This adds WebContentClient::notify_all_views_of_crash() which iterates over all registered views and notifies each one. Child views also now propagate crashes to their parent, and can be disconnected between tests to prevent stale crashes from affecting subsequent tests.
2026-01-13 19:32:16 -03:00
friend class WebContentClient;
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 09:32:17 -03:00
public:
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
virtual ~ViewImplementation();
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 09:32:17 -03:00
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 void for_each_view(Function<IterationDecision(ViewImplementation&)>);
static Optional<ViewImplementation&> find_view_by_id(u64);
u64 view_id() const { return m_view_id; }
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 set_url(Badge<WebContentClient>, URL::URL url) { set_url(move(url)); }
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 00:22:27 -03:00
URL::URL const& url() const { return m_url; }
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 17:30:06 -03:00
LibWeb+LibWebView+WebContent+UI: Port the document title to UTF-16
2025-07-28 17:51:01 -03:00
void set_title(Badge<WebContentClient>, Utf16String title) { m_title = move(title); }
Utf16String const& title() const { return m_title; }
LibWebView: Store the tab title on the ViewImplementation This will be needed for DevTools, to avoid the need to go into the UI layer for this information.
2025-02-17 08:43:06 -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 set_favicon(Badge<WebContentClient>, Gfx::Bitmap const&);
Optional<String> const& favicon_base64_png() const { return m_favicon_base64_png; }
LibWebView: Add window handle in `ClientState` in `ViewImplementation` Add field for a handle that is going to be used by WebDriver to identify top-level browsing contexts. It is supposed to be populated by WebContent client during creation. Co-authored-by: Timothy Flynn <trflynn89@pm.me>
2023-03-16 12:24:30 -03:00
String const& handle() const { return m_client_state.client_handle; }
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 create_new_process_for_cross_site_navigation(URL::URL const&, Variant<Empty, String, Web::HTML::POSTResource>, Web::Bindings::NavigationHistoryBehavior);
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 server_did_paint(Badge<WebContentClient>, i32 bitmap_id, Gfx::IntSize size);
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 set_window_position(Gfx::IntPoint);
void set_window_size(Gfx::IntSize);
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 did_update_window_rect();
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
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 set_system_visibility_state(Web::HTML::VisibilityState);
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 load(URL::URL const&, Web::Bindings::NavigationHistoryBehavior = Web::Bindings::NavigationHistoryBehavior::Auto);
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 load_html(StringView);
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 load_navigation_error_page(StringView);
LibWeb+LibWebView+WebContent: Add an IPC call for Navigable::reload()
2024-04-13 13:51:27 -03:00
void 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
enum class HistoryTraversalStatus : u8 {
Started,
NoEntry,
Canceled,
};
// NB: The HTML Standard spells this algorithm argument "checkForCancelation".
enum class CheckForCancelation : u8 {
Yes,
No,
IfWebContentCannotTraverseTarget,
};
struct HistoryTraversalOutcome {
HistoryTraversalStatus status { HistoryTraversalStatus::NoEntry };
bool will_replace_web_content_process { false };
bool will_change_top_level_entry { false };
bool waiting_for_cancelation_check { false };
};
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
struct SessionHistoryTraversalMenuItem {
int delta { 0 };
String title;
String url;
Optional<String> favicon_base64_png;
};
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
[[nodiscard]] HistoryTraversalOutcome traverse_the_history_by_delta(
int delta,
CheckForCancelation = CheckForCancelation::Yes,
Function<void(HistoryTraversalOutcome)> = nullptr);
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
[[nodiscard]] Vector<SessionHistoryTraversalMenuItem> session_history_traversal_menu_items(int direction) const;
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 17:30:06 -03:00
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 16:49:49 -03:00
void zoom_in();
void zoom_out();
LibWeb+UI: Add internals API to set browser zoom
2024-12-23 18:15:06 -03:00
void set_zoom(double zoom_level);
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 16:49:49 -03:00
void 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
double zoom_level() const { return m_zoom_level; }
double device_pixel_ratio() const { return m_device_pixel_ratio; }
LibWebView+UI: Replay display metadata after Compositor restart Compositor recovery recreated contexts and replayed viewport sizes, but it left the restarted helper with the default display metadata. A recovered context could fall back to a 60 Hz timer instead of the window's current display id and refresh rate until the frontend later observed a screen change. Store the display id in the shared view state, alongside the existing maximum frame rate, and replay both values while restoring view state after reconnect.
2026-05-31 15:16:39 -03:00
Optional<u64> display_id() const { return m_display_id; }
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
double maximum_frames_per_second() const { return m_maximum_frames_per_second; }
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -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 enqueue_input_event(Web::InputEvent);
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 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
LibWebView+Ladybird: Move preferred color scheme to ViewImplementation
2023-01-12 17:44:42 -03:00
void set_preferred_color_scheme(Web::CSS::PreferredColorScheme);
LibWeb: Add Contrast preference
2024-06-12 20:03:56 -03:00
void set_preferred_contrast(Web::CSS::PreferredContrast);
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 set_preferred_motion(Web::CSS::PreferredMotion);
LibWeb: Support sending DNT header with requests
2024-07-02 16:29:43 -03:00
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 notify_cookies_changed(HashTable<String> const& changed_domains, ReadonlySpan<HTTP::Cookie::Cookie> page_cookies, ReadonlySpan<HTTP::Cookie::Cookie> host_cookies);
void listen_for_host_cookie_changes(DevTools::DevToolsDelegate::OnHostCookieChange);
void stop_listening_for_host_cookie_changes();
LibDevTools+LibWeb: Send IndexedDB change updates The Storage panel expects storesUpdate messages after watched storage changes. Summarize committed IndexedDB mutation logs into DevTools paths and forward them through WebContent so Firefox can refresh database, object-store, and record rows without polling. Firefox's behaviour is less than ideal here. A lot of things don't update automatically even inspecting a page in Firefox. Some things (like new databases) won't show up until you fully refresh the page. So that makes it a bit hard to know that we're doing things correctly. As far as I can tell, we are at least behaving as well as Firefox requires. We do have one workaround: Firefox doesn't display record updates without a manual refresh, and in fact any change messages for them show up as rows in the host's database table. So for now, we filter them out to avoid visual weirdness in the inspector.
2026-06-11 12:51:05 -03:00
void notify_indexed_database_changed(JsonObject);
u64 add_indexed_database_change_listener(DevTools::DevToolsDelegate::OnIndexedDatabaseChange);
void remove_indexed_database_change_listener(u64 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> ensure_document_cookie_version_index(Badge<WebContentClient>, String const&);
Optional<Core::SharedVersion> document_cookie_version(URL::URL const&) const;
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+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 notify_storage_changed(DevTools::DevToolsDelegate::StorageChange);
u64 add_storage_change_listener(DevTools::DevToolsDelegate::OnStorageChange);
void remove_storage_change_listener(u64 listener_id);
LibDevTools+LibWeb: Show IndexedDB in DevTools Firefox asks the storage watcher for an indexed-db resource before it shows IndexedDB entries in the Storage panel. Add an IndexedDB actor and serialize the live LibWeb database registry on demand, so WebContent can return the host tree and table rows without duplicating database state. Use the LibWeb inspection helpers to read IndexedDB internals, and keep the Firefox protocol shape in LibDevTools. WebContent only forwards the serialized response over the existing DevTools IPC path.
2026-06-17 08:39:37 -03:00
void inspect_indexed_database_storage(DevTools::DevToolsDelegate::OnIndexedDBInspectionComplete);
void inspect_indexed_database_objects(String const& host, Optional<JsonArray> names, JsonObject options, DevTools::DevToolsDelegate::OnIndexedDBInspectionComplete);
LibDevTools+LibWeb: Let DevTools remove IndexedDB data Firefox exposes removal operations for IndexedDB databases, object stores, and records from the Storage panel. Route those actor requests to LibWeb so DevTools can delete the selected data and receive the update or clear event needed to refresh the panel.
2026-06-11 12:59:48 -03:00
void delete_indexed_database(String const& host, String const& name, DevTools::DevToolsDelegate::OnIndexedDBInspectionComplete);
void clear_indexed_database_object_store(String const& host, String const& name, DevTools::DevToolsDelegate::OnIndexedDBInspectionComplete);
void delete_indexed_database_record(String const& host, String const& name, DevTools::DevToolsDelegate::OnIndexedDBInspectionComplete);
LibDevTools+LibWeb: Show IndexedDB in DevTools Firefox asks the storage watcher for an indexed-db resource before it shows IndexedDB entries in the Storage panel. Add an IndexedDB actor and serialize the live LibWeb database registry on demand, so WebContent can return the host tree and table rows without duplicating database state. Use the LibWeb inspection helpers to read IndexedDB internals, and keep the Firefox protocol shape in LibDevTools. WebContent only forwards the serialized response over the existing DevTools IPC path.
2026-06-17 08:39:37 -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 selected_text();
LibWeb+LibWebView+WebContent+UI: Add an action to cut text
2026-05-06 13:00:59 -03:00
ByteString cut_selected_text();
LibWebView: Add a helper to get selected text with collapsed whitespace
2023-10-23 17:52:57 -03:00
Optional<String> selected_text_with_whitespace_collapsed();
LibWebView+Ladybird: Move text selection to ViewImplementation
2023-01-12 17:42:42 -03:00
void select_all();
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 find_in_page(String const& query, CaseSensitivity = CaseSensitivity::CaseInsensitive);
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 find_in_page_next_match();
void find_in_page_previous_match();
LibWebView+Ladybird: Move text selection to ViewImplementation
2023-01-12 17:42:42 -03:00
LibWebView+Ladybird: Move get source request to ViewImplementation
2023-01-12 16:58:00 -03:00
void get_source();
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 16:49:49 -03:00
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
void inspect_dom_tree();
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 inspect_storage(Web::StorageAPI::StorageEndpointType, u64 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> set_session_storage_item(String const& key, String const& value);
Optional<String> remove_session_storage_item(String const& key);
bool clear_session_storage();
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -03:00
void inspect_accessibility_tree();
LibWebView+WebContent: Make the hovered node retrieval IPC async
2023-12-30 11:42:24 -03:00
void get_hovered_node_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 start_node_picker(DevTools::DevToolsDelegate::OnNodePickerEvent);
void stop_node_picker();
void clear_node_picker();
bool is_node_picker_active() const { return m_node_picker_active; }
void node_picker_hover(Web::DevicePixelPoint);
void node_picker_pick(Web::DevicePixelPoint);
void node_picker_preview(Web::DevicePixelPoint);
void node_picker_cancel();
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 17:22:14 -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
void inspect_dom_node(Web::UniqueNodeID node_id, DOMNodeProperties::Type, Optional<Web::CSS::PseudoElement> pseudo_element, JsonValue options = {});
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 inspect_grid_layouts(Web::UniqueNodeID root_node_id);
void inspect_current_grid(Web::UniqueNodeID node_id);
WebContent+LibWebView: Add flexbox inspection plumbing
2026-05-27 12:41:13 -03:00
void inspect_current_flexbox(Web::UniqueNodeID node_id, bool only_look_at_parents);
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 clear_inspected_dom_node();
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 highlight_dom_node(Web::UniqueNodeID node_id, Optional<Web::CSS::PseudoElement> 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 clear_highlighted_dom_node();
DevTools+WebContent: Support the flexbox highlighter
2026-05-27 13:12:14 -03:00
void highlight_flexbox(Web::UniqueNodeID node_id, JsonValue options);
void clear_flexbox_highlight(Web::UniqueNodeID 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 highlight_grid(Web::UniqueNodeID node_id, JsonValue options);
void clear_grid_highlight(Web::UniqueNodeID node_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
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 set_listen_for_dom_mutations(bool);
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 did_connect_devtools_client();
void did_disconnect_devtools_client();
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 get_dom_node_inner_html(Web::UniqueNodeID 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 get_dom_node_outer_html(Web::UniqueNodeID node_id);
void set_dom_node_outer_html(Web::UniqueNodeID node_id, String const& html);
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
void set_dom_node_text(Web::UniqueNodeID node_id, String const& text);
void set_dom_node_tag(Web::UniqueNodeID node_id, String const& name);
void add_dom_node_attributes(Web::UniqueNodeID node_id, ReadonlySpan<Attribute> attributes);
void replace_dom_node_attribute(Web::UniqueNodeID node_id, String const& name, ReadonlySpan<Attribute> replacement_attributes);
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 create_child_element(Web::UniqueNodeID node_id);
void create_child_text_node(Web::UniqueNodeID node_id);
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 insert_dom_node_before(Web::UniqueNodeID node_id, Web::UniqueNodeID parent_node_id, Optional<Web::UniqueNodeID> 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 clone_dom_node(Web::UniqueNodeID node_id);
void remove_dom_node(Web::UniqueNodeID node_id);
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
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 list_style_sheets();
void request_style_sheet_source(Web::CSS::StyleSheetIdentifier const&);
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 debug_request(ByteString const& request, ByteString const& argument = {});
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 set_content_blockers(Core::AnonymousBuffer const& patterns);
LibWebView+Ladybird: Move debug request to ViewImplementation
2023-01-12 17:34:08 -03:00
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
void run_javascript(String const&);
void js_console_input(String const&);
LibWeb: Implement exitFullscreen algorithm Exiting fullscreen from the UI will be added in future commits.
2025-04-01 09:23:04 -03:00
void exit_fullscreen();
LibWebView+Ladybird: Move running JavaScript to ViewImplementation
2023-01-12 17:39:08 -03:00
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 set_is_fullscreen(Web::ViewportIsFullscreen is_fullscreen);
UI/Qt: Create a bookmarks application menu and toolbar
2026-03-22 20:25:10 -03:00
Web::ViewportIsFullscreen is_fullscreen() const { return m_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
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 15:23:34 -03:00
void alert_closed();
void confirm_closed(bool accepted);
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
void prompt_closed(Optional<String> const& response);
LibWeb: Allow input color to give continuous updates
2023-12-11 02:53:10 -03:00
void color_picker_update(Optional<Color> picked_color, Web::HTML::ColorPickerUpdateState state);
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 file_picker_closed(Vector<Web::HTML::SelectedFile> 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 select_dropdown_closed(Optional<u32> const& selected_item_id);
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 15:23:34 -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 paste_text_from_clipboard();
LibWeb+LibWebVew+WebContent+UI: Add IPC to retrieve the system clipboard We currently have a single IPC to set clipboard data. We will also need an IPC to retrieve that data from the UI. This defines system clipboard data in LibWeb to handle this transfer, and adds the IPC to provide it.
2025-05-01 12:38:31 -03:00
void retrieved_clipboard_entries(u64 request_id, ReadonlySpan<Web::Clipboard::SystemClipboardItem>);
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
// Used by platform input methods to drive marked/preedit-text composition, and to query the on-screen caret
// position for placing IME overlays.
void set_marked_text_from_input_method(Utf16String const& text);
void commit_text_from_input_method(Utf16String const& text);
void unmark_text_from_input_method();
Optional<Web::DevicePixelRect> get_input_caret_rect();
void set_input_caret_rect(Badge<WebContentClient>, Optional<Web::DevicePixelRect>);
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
Web::HTML::MuteState page_mute_state() const { return m_mute_state; }
void toggle_page_mute_state();
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 did_change_audio_play_state(Badge<WebContentClient>, Web::HTML::AudioPlayState);
Web::HTML::AudioPlayState audio_play_state() const { return 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 did_update_navigation_buttons_state(Badge<WebContentClient>, bool back_enabled, bool forward_enabled);
void did_update_session_history(Badge<WebContentClient>, Vector<Web::HTML::SessionHistoryEntryDescriptor>, Vector<i32>, size_t current_used_step_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
void did_update_session_history_for_testing(Badge<WebContentClient>, Vector<Web::HTML::SessionHistoryEntryDescriptor>, Vector<i32>, size_t current_used_step_index);
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 did_set_top_level_session_history(Badge<WebContentClient>, bool accepted, Vector<Web::HTML::SessionHistoryEntryDescriptor>, Vector<i32> used_steps, size_t current_used_step_index);
void did_traverse_the_history_to_step(Badge<WebContentClient>, i32 step, bool step_was_available, Web::HTML::HistoryStepResult);
void did_check_if_traverse_history_step_is_canceled(
Badge<WebContentClient>, u64 request_id, i32 step, bool canceled);
void did_reset_session_history_for_testing(Badge<WebContentClient>);
void mark_web_content_session_history_stale_for_testing(Badge<WebContentClient>);
void did_start_webdriver_navigation(Badge<WebContentClient>, URL::URL const&);
String ui_process_session_history_for_testing(Badge<WebContentClient>) const;
JsonValue webdriver_session_history() const;
void wait_for_webdriver_navigation_completion(Badge<WebContentClient>, Optional<u64> page_load_timeout, Function<void(Web::WebDriver::Response)>);
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 did_change_needs_beforeunload_check(Badge<WebContentClient>, bool 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 did_change_background_color(Badge<WebContentClient>, Gfx::Color);
Gfx::Color page_background_color() const { return m_page_background_color; }
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
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 did_allocate_backing_stores(Badge<WebContentClient>, i32 front_bitmap_id, Gfx::SharedImage front_backing_store, i32 back_bitmap_id, Gfx::SharedImage back_backing_store);
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
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
enum class ScreenshotType {
Visible,
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
NonnullRefPtr<Core::Promise<LexicalPath>> take_screenshot(ScreenshotType);
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>> take_dom_node_screenshot(Web::UniqueNodeID);
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
virtual void did_receive_screenshot(Badge<WebContentClient>, Gfx::ShareableBitmap const&);
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>> request_internal_page_info(PageInfoType);
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 did_receive_internal_page_info(Badge<WebContentClient>, PageInfoType, Optional<Core::AnonymousBuffer> const&);
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
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> dump_gc_graph();
LibDevTools+LibWebView: Take advantage of IPC encoding improvements
2025-03-08 13:00:03 -03:00
void 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
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 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
Function<void()> prepare_for_immediate_close();
bool needs_beforeunload_check() const { return m_needs_beforeunload_check; }
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
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
Function<void()> on_ready_to_paint;
Ladybird: Add IPC call for creating a new child tab This will be used for choosing a navigable that requires opening a new tab or new window. Such as calls to window.open(), or specific WebDriver calls.
2024-01-31 00:05:00 -03:00
Function<String(Web::HTML::ActivateTab, Web::HTML::WebViewHints, Optional<u64>)> on_new_web_view;
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 13:37:31 -03:00
Function<void()> on_activate_tab;
Function<void()> on_close;
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-28 23:02:55 -03:00
Function<void(URL::URL const&)> on_link_hover;
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 13:37:31 -03:00
Function<void()> on_link_unhover;
LibWeb+LibWebView+WebContent+UI: Port the document title to UTF-16
2025-07-28 17:51:01 -03:00
Function<void(Utf16String const&)> on_title_change;
LibWeb+LibWebView+WebContent: Add did_change_url() IPC call
2024-04-14 05:27:20 -03:00
Function<void(URL::URL const&)> on_url_change;
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-28 23:02:55 -03:00
Function<void(URL::URL const&, bool)> on_load_start;
Function<void(URL::URL const&)> on_load_finish;
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
struct NavigationListener {
Function<void(URL::URL const&, bool)> on_load_start;
Function<void(URL::URL const&)> on_load_finish;
};
u64 add_navigation_listener(NavigationListener);
void remove_navigation_listener(u64 listener_id);
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
Function<void(ByteString const& path, i32)> on_request_file;
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 13:37:31 -03:00
Function<void(Gfx::Bitmap const&)> on_favicon_change;
LibWeb+WebContent+UI: Support image cursors The `cursor` property accepts a list of possible cursors, which behave as a fallback: We use whichever cursor is the first available one. This is a little complicated because initially, any remote images have not loaded, so we need to use the fallback standard cursor, and then switch to another when it loads. So, ComputedValues stores a Vector of cursors, and then in EventHandler we scan down that list until we find a cursor that's ready for use. The spec defines cursors as being `<url>`, but allows for `<image>` instead. That includes functions like `linear-gradient()`. This commit implements image cursors in the Qt UI, but not AppKit.
2025-02-20 09:17:29 -03:00
Function<void(Gfx::Cursor const&)> on_cursor_change;
LibWeb+UI: Add tooltip overriding and use it for <video> tags This call is used to inform the chrome that it should display a tooltip now and avoid any hovering timers. This is used by <video> tags to display the volume percentage when it is changed.
2024-07-02 11:48:57 -03:00
Function<void(Gfx::IntPoint, ByteString const&)> on_request_tooltip_override;
Function<void()> on_stop_tooltip_override;
LibWeb+UI/Qt: Display 'title' tooltips only when the mouse stops moving Now instead of sending the position in which the user entered the tooltip area, send just the text, and let the chrome figure out how to display it. In the case of Qt, wait for 600 milliseconds of no mouse movement, then display it under the mouse cursor.
2024-07-02 09:16:24 -03:00
Function<void(ByteString const&)> on_enter_tooltip_area;
Ladybird+LibWebView: Migrate tooltip changes to LibWebView callbacks
2023-08-23 12:11:39 -03:00
Function<void()> on_leave_tooltip_area;
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 15:23:34 -03:00
Function<void(String const& message)> on_request_alert;
Function<void(String const& message)> on_request_confirm;
Function<void(String const& message, String const& default_)> on_request_prompt;
Function<void(String const& message)> on_request_set_prompt_text;
Function<void()> on_request_accept_dialog;
Function<void()> on_request_dismiss_dialog;
LibWebView: Parse inspector-related JSON strings sooner We currently receive serialized JSON values over IPC and forward them to them WebView callbacks, leaving it to the implementations of those callbacks to parse the strings as JSON objects. This patch hoists that parsing up to WebContentClient as soon as the IPC message is received. This is to reduce the work needed for secondary implementations of these callbacks (i.e. our Firefox DevTools server).
2025-02-21 14:39:43 -03:00
Function<void(JsonObject)> on_received_dom_tree;
Function<void(DOMNodeProperties)> on_received_dom_node_properties;
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
HashMap<u64, Function<void(ErrorOr<Vector<DevTools::DevToolsDelegate::StorageItem>>)>> on_received_storage_items;
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
Function<void(JsonArray)> on_received_grid_layouts;
Function<void(Optional<JsonObject>)> on_received_current_grid;
WebContent+LibWebView: Add flexbox inspection plumbing
2026-05-27 12:41:13 -03:00
Function<void(Optional<JsonObject>)> on_received_current_flexbox;
LibWebView: Parse inspector-related JSON strings sooner We currently receive serialized JSON values over IPC and forward them to them WebView callbacks, leaving it to the implementations of those callbacks to parse the strings as JSON objects. This patch hoists that parsing up to WebContentClient as soon as the IPC message is received. This is to reduce the work needed for secondary implementations of these callbacks (i.e. our Firefox DevTools server).
2025-02-21 14:39:43 -03:00
Function<void(JsonObject)> on_received_accessibility_tree;
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
Function<void(Web::UniqueNodeID)> on_received_hovered_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
Function<void(Mutation)> on_dom_mutation_received;
LibWeb: Fix typos - act II
2025-04-07 07:46:22 -03:00
Function<void(Optional<Web::UniqueNodeID> const& node_id)> on_finished_editing_dom_node;
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
Function<void(String)> on_received_dom_node_html;
LibWeb+LibWebView+WebContent: Remove the built-in Inspector
2025-03-14 17:22:16 -03:00
Function<void(Vector<Web::CSS::StyleSheetIdentifier>)> on_received_style_sheet_list;
Function<void(Web::CSS::StyleSheetIdentifier const&, URL::URL const&, String const&)> on_received_style_sheet_source;
LibWebView+WebContent: Begin supporting the DevTools JavaScript console This supports evaluating the script and replying with the result. We currently serialize JS objects to a string, but we will need to support dynamic interaction with the objects over IPC. This does not yet support sending console messages to DevTools.
2025-02-24 13:57:33 -03:00
Function<void(JsonValue)> on_received_js_console_result;
LibDevTools: Stream console messages instead of polling by index Previously, console messages were sent using an index-based system where DevTools would be notified of new message indices and then request them in batches. This created synchronization issues during page navigation when the WebContent process resets while DevTools still has stale index state. This changes to a push-based model where console messages are sent immediately as resources when they are logged, matching how Firefox DevTools handles console messages. Each message is pushed through IPC and forwarded to DevTools as a "console-message" or "error-message" resource. This eliminates the need for index tracking in FrameActor and simplifies the entire console message pipeline from WebContent through to DevTools.
2026-01-14 16:13:24 -03:00
Function<void(ConsoleOutput)> on_console_message;
LibDevTools: Pass request initiator type to network panel Propagate the request initiator type (e.g., "xmlhttprequest", "fetch", "script", "stylesheet") from LibWeb through the IPC layer to DevTools. This enables Firefox DevTools to correctly identify XHR/fetch requests and display appropriate cause types in the Network panel's "Initiator" column.
2026-01-14 19:24:51 -03:00
Function<void(u64 request_id, URL::URL const&, ByteString const&, Vector<HTTP::Header> const&, ByteBuffer, Optional<String>)> on_network_request_started;
LibDevTools: Add Firefox DevTools network monitoring support Hook ResourceLoader to emit network request lifecycle events through IPC to the UI process, where FrameActor creates NetworkEventActor instances that serialize requests using Firefox's Remote Debug Protocol. The Network panel now shows requests with method, URL, status, MIME type, size, and timing information. Several features remain stubbed (POST data, response content, cause detection) marked with FIXMEs.
2026-01-14 14:43:48 -03:00
Function<void(u64 request_id, u32 status_code, Optional<String> const&, Vector<HTTP::Header> const&)> on_network_response_headers_received;
LibDevTools: Add request and response body viewing to network panel This adds support for viewing request payloads (POST data) and response bodies in the Firefox DevTools network panel. Request bodies are captured when network requests start and passed through IPC to the NetworkEventActor, which returns them via the getRequestPostData protocol method. Response bodies are streamed via a new IPC message as data is received, accumulated in NetworkEventActor (with a 10MB size limit to prevent memory issues), and returned via getResponseContent. Text content is returned as UTF-8, while binary content (images, etc.) is base64.
2026-01-14 16:47:04 -03:00
Function<void(u64 request_id, ByteBuffer)> on_network_response_body_received;
LibDevTools: Add Firefox DevTools network monitoring support Hook ResourceLoader to emit network request lifecycle events through IPC to the UI process, where FrameActor creates NetworkEventActor instances that serialize requests using Firefox's Remote Debug Protocol. The Network panel now shows requests with method, URL, status, MIME type, size, and timing information. Several features remain stubbed (POST data, response content, cause detection) marked with FIXMEs.
2026-01-14 14:43:48 -03:00
Function<void(u64 request_id, u64 body_size, Requests::RequestTimingInfo const&, Optional<Requests::NetworkError> const&)> on_network_request_finished;
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 13:37:31 -03:00
Function<void(i32 count_waiting)> on_resource_status_change;
Function<void()> on_restore_window;
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
Function<void(Gfx::IntPoint)> on_reposition_window;
Function<void(Gfx::IntSize)> on_resize_window;
LibWeb+WebContent+WebDriver+UI: Make window min/maximize asynchronous This follows suit of previous changes to never block the WebContent process in WebDriver endpoints.
2024-10-29 00:45:18 -03:00
Function<void()> on_maximize_window;
Function<void()> on_minimize_window;
Function<void()> on_fullscreen_window;
LibWebView+UI/Qt: Allow WebContent to enter/exit the fullscreen UI These IPC methods should be expanded in the future to allow WebContent to specify what UI elements should be kept/removed, for example, the navigation UI.
2025-03-27 11:59:17 -03:00
Function<void()> on_exit_fullscreen_window;
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
Function<void(Color current_color)> on_request_color_picker;
Ladybird+LibWeb+WebContent: Parse the <input type=file> accept attribute This parses the accept attribute value for file input types and passes it along to the browser chromes.
2024-03-14 13:26:00 -03:00
Function<void(Web::HTML::FileFilter const& accepted_file_types, Web::HTML::AllowMultipleFiles)> on_request_file_picker;
Ladybird+LibWeb: Add basic select element support
2023-12-07 11:53:49 -03:00
Function<void(Gfx::IntPoint content_position, i32 minimum_width, Vector<Web::HTML::SelectItem> items)> on_request_select_dropdown;
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
Function<void(Web::KeyEvent const&)> on_finish_handling_key_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
Function<void(Web::DragEvent const&)> on_finish_handling_drag_event;
LibWeb: Rename internals.signalTextTestIsDone() to signalTestIsDone() In upcoming change this function will be used for ref-tests as well.
2025-03-18 13:37:32 -03:00
Function<void(String const&)> on_test_finish;
headless-browser: Let tests set their own timeout duration Some tests take longer than others, and so may want to set a custom timeout so that they pass, without increasing the timeout for all other tests. For example, this is done in WPT. Add an `internals.setTestTimeout(milliseconds)` method that overrides the test runner's default timeout for the currently-run test.
2024-12-19 11:16:05 -03:00
Function<void(double milliseconds)> on_set_test_timeout;
Tests: Replace `load-reference-page` debug action with internals method WPT reference tests can add metadata to tests to instruct the test runner how to interpret the results. Because of this, it is not enough to have an action that starts loading the (mis)match reference: we need the test runner to receive the metadata so it can act accordingly. This sets our test runner up for potentially supporting multiple (mis)match references, and fuzzy rendering matches - the latter will be implemented in the following commit.
2025-07-16 05:24:15 -03:00
Function<void(JsonValue)> on_reference_test_metadata;
LibWeb+WebContent: Provide feedback on find in page requests This change allows the results of a find in page query to be reported back to the user interface. Currently, the number of results found and the current match index are reported.
2024-06-09 14:35:32 -03:00
Function<void(size_t current_match_index, Optional<size_t> const& total_match_count)> on_find_in_page;
LibWeb+LibWebView+WebContent: Add support for meta theme-color
2023-09-18 20:51:48 -03:00
Function<void(Gfx::Color)> on_theme_color_change;
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
Function<void(Gfx::Color)> on_page_background_color_change;
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
Function<void(Web::HTML::AudioPlayState)> on_audio_play_state_changed;
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
Function<void()> on_web_content_crashed;
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
Function<void()> on_web_content_process_change_for_cross_site_navigation;
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
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
Menu& page_context_menu() { return *m_page_context_menu; }
Menu& link_context_menu() { return *m_link_context_menu; }
Menu& image_context_menu() { return *m_image_context_menu; }
Menu& media_context_menu() { return *m_media_context_menu; }
LibWeb+LibWebView+WebContent+UI: Add an action to cut text
2026-05-06 13:00:59 -03:00
void 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
void did_request_link_context_menu(Badge<WebContentClient>, Gfx::IntPoint content_position, URL::URL url);
void did_request_image_context_menu(Badge<WebContentClient>, Gfx::IntPoint content_position, URL::URL url, Optional<Gfx::ShareableBitmap> bitmap);
void did_request_media_context_menu(Badge<WebContentClient>, Gfx::IntPoint content_position, Web::Page::MediaContextMenu menu);
Action& navigate_back_action() { return *m_navigate_back_action; }
Action& navigate_forward_action() { return *m_navigate_forward_action; }
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
Action& toggle_bookmark_action() { return *m_toggle_bookmark_action; }
LibWebView+UI: Generate the zoom menu
2025-09-10 08:23:15 -03:00
Action& reset_zoom_action() { return *m_reset_zoom_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
UI: Add WebContent PID debug preference Register debug.process.show_web_content_process_id and use it to append the active WebContent process ID to tab titles and tab tooltips in the Qt, Gtk, and AppKit frontends. Keep the stored page title unchanged so toggling the preference can refresh each tab without waiting for a new title update.
2026-05-24 05:02:05 -03:00
WebContentClient& client();
WebContentClient const& client() const;
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 11:53:55 -03:00
virtual Web::DevicePixelSize viewport_size() const = 0;
Browser+Ladybird+LibWebView: Virtualize computing content/widget points This will allow moving some copy-pasted functionality from web view implementations to the base LibWebView class.
2023-05-17 11:12:13 -03:00
virtual Gfx::IntPoint to_content_position(Gfx::IntPoint widget_position) const = 0;
virtual Gfx::IntPoint to_widget_position(Gfx::IntPoint content_position) const = 0;
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+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
protected:
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
static constexpr auto ZOOM_MIN_LEVEL = 0.3;
static constexpr auto ZOOM_MAX_LEVEL = 5.0;
static constexpr auto ZOOM_STEP = 0.1;
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 16:49:49 -03:00
Ladybird+LibWebView+Browser: Remove ability to run with AST interpreter
2023-08-07 11:44:20 -03:00
ViewImplementation();
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
u64 page_id() const;
LibWebView+UI: Generate the zoom menu
2025-09-10 08:23:15 -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 set_url(URL::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
void did_start_navigation(URL::URL const&, Variant<Empty, String, Web::HTML::POSTResource>, bool is_redirect, Web::Bindings::NavigationHistoryBehavior);
void did_cancel_navigation(URL::URL const&);
void did_finish_navigation(URL::URL const&);
void complete_webdriver_navigation_completion(u64 request_id, Web::WebDriver::Response);
void complete_webdriver_pending_navigation_if_url_matches(URL::URL const&);
void update_navigation_action_state();
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
TraversableSessionHistory::UpdateResult update_session_history_from_web_content(Vector<Web::HTML::SessionHistoryEntryDescriptor>, 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);
bool adopt_web_content_session_history_after_rejected_seed(Vector<Web::HTML::SessionHistoryEntryDescriptor>, Vector<i32> used_steps, size_t current_used_step_index);
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
enum class SessionHistoryDumpMode {
IfDebuggingEnabled,
Always,
};
void dump_session_history(StringView reason, SessionHistoryDumpMode = SessionHistoryDumpMode::IfDebuggingEnabled) const;
bool restore_pending_session_history_navigation(StringView reason);
void abandon_pending_web_content_session_history_seed();
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
enum class AllowCurrentEntryReconstruction : u8 {
No,
Yes,
};
void seed_web_content_session_history_from_ui_process(AllowCurrentEntryReconstruction = 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
void prepare_to_seed_web_content_session_history_from_ui_process();
void restore_current_session_history_entry_from_ui_process();
void load_current_session_history_entry_from_ui_process();
void load_session_history_traversal_target_from_ui_process(TraversableSessionHistory::TraversalTarget const&, StringView dump_reason);
NonnullRefPtr<Core::Promise<Empty>> reset_session_history_for_testing();
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
LibWebView+UI: Generate the zoom menu
2025-09-10 08:23:15 -03:00
virtual void update_zoom();
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
virtual bool should_manage_session_history_in_ui_process() const { return true; }
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 current_host() const;
void apply_zoom_for_current_host();
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
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
void handle_resize();
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 set_page_background_color_to_system_canvas(bool dark);
void set_page_background_color(Gfx::Color);
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 preferred_canvas_background_color() const;
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 load_crash_page_html(StringView, URL::URL const& crashed_url);
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: Add ability to create a tab without creating a new WebContent
2024-01-30 13:12:14 -03:00
enum class CreateNewClient {
No,
Yes,
};
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
virtual void initialize_client(CreateNewClient = CreateNewClient::Yes);
Ladybird+LibWebView: Add -P/--enable-callgrind-profiling option This adds a -P option to run Ladybird under callgrind. It starts with instrumentation disabled. To start capturing a profile (once Ladybird has launched) run `callgrind_control -i on` and to stop it again run `callgrind_control -i off`. P.s. This is pretty much stolen from Andreas (and is based on the patch everyone [that wants a profile] have been manually applying).
2023-04-14 21:04:28 -03:00
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
enum class LoadErrorPage {
No,
Yes,
};
void handle_web_content_process_crash(LoadErrorPage = LoadErrorPage::Yes);
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
virtual void default_zoom_level_factor_changed() override;
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
virtual void zoom_per_host_changed(StringView host) override;
LibWeb+LibWebView+UI: Migrate to LibWebView's language settings
2025-04-03 14:53:02 -03:00
virtual void languages_changed() override;
LibWeb+LibWebView+WebContent: Add a setting to control autoscrolling
2026-04-13 11:55:24 -03:00
virtual void browsing_behavior_changed() override;
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
virtual void autoplay_settings_changed() override;
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
virtual void global_privacy_control_changed() override;
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: 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
virtual void bookmarks_changed() override;
void update_bookmark_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
void initialize_context_menus();
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
struct SharedBitmap {
i32 id { -1 };
LibWeb: Refactor int types in WebContentServer to DevicePixels
2023-12-14 03:17:00 -03:00
Web::DevicePixelSize last_painted_size;
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
OwnPtr<Gfx::SharedImageBuffer> shared_image_buffer;
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
};
struct ClientState {
RefPtr<WebContentClient> client;
LibWebView: Add window handle in `ClientState` in `ViewImplementation` Add field for a handle that is going to be used by WebDriver to identify top-level browsing contexts. It is supposed to be populated by WebContent client during creation. Co-authored-by: Timothy Flynn <trflynn89@pm.me>
2023-03-16 12:24:30 -03:00
String client_handle;
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
SharedBitmap front_bitmap;
SharedBitmap back_bitmap;
Ladybird: Add ability to create a tab without creating a new WebContent
2024-01-30 13:12:14 -03:00
u64 page_index { 0 };
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
bool has_usable_bitmap { false };
} m_client_state;
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 16:49:49 -03:00
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 00:22:27 -03:00
URL::URL m_url;
LibWeb+LibWebView+WebContent+UI: Port the document title to UTF-16
2025-07-28 17:51:01 -03:00
Utf16String m_title;
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
Optional<String> m_favicon_base64_png;
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
bool m_is_showing_crash_page { false };
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 17:30:06 -03:00
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
double m_zoom_level { 1.0 };
double m_device_pixel_ratio { 1.0 };
LibWebView+UI: Replay display metadata after Compositor restart Compositor recovery recreated contexts and replayed viewport sizes, but it left the restarted helper with the default display metadata. A recovered context could fall back to a 60 Hz timer instead of the window's current display id and refresh rate until the frontend later observed a screen change. Store the display id in the shared view state, alongside the existing maximum frame rate, and replay both values while restoring view state after reconnect.
2026-05-31 15:16:39 -03:00
Optional<u64> m_display_id;
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
double m_maximum_frames_per_second { 60.0 };
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: 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
RefPtr<Menu> m_page_context_menu;
RefPtr<Menu> m_link_context_menu;
RefPtr<Menu> m_image_context_menu;
RefPtr<Menu> m_media_context_menu;
RefPtr<Action> m_navigate_back_action;
RefPtr<Action> m_navigate_forward_action;
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
RefPtr<Action> m_toggle_bookmark_action;
LibWebView+UI: Generate the zoom menu
2025-09-10 08:23:15 -03:00
RefPtr<Action> m_reset_zoom_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
RefPtr<Action> m_search_selected_text_action;
Optional<String> m_search_text;
RefPtr<Action> m_take_visible_screenshot_action;
RefPtr<Action> m_take_full_screenshot_action;
RefPtr<Action> m_open_in_new_tab_action;
UI+LibWebView: Implement "Open Link in New Window"
2026-02-17 16:23:45 -03:00
RefPtr<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
RefPtr<Action> m_copy_url_action;
URL::URL m_context_menu_url;
RefPtr<Action> m_open_image_action;
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
RefPtr<Action> m_save_image_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
RefPtr<Action> m_copy_image_action;
Optional<Gfx::ShareableBitmap> m_image_context_menu_bitmap;
RefPtr<Action> m_open_audio_action;
RefPtr<Action> m_open_video_action;
RefPtr<Action> m_media_play_action;
RefPtr<Action> m_media_pause_action;
RefPtr<Action> m_media_mute_action;
RefPtr<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
RefPtr<Action> m_media_show_controls_action;
RefPtr<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
RefPtr<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
RefPtr<Action> m_media_enter_fullscreen_action;
RefPtr<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
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
Queue<Web::InputEvent> m_pending_input_events;
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
RefPtr<Core::Timer> m_backing_store_shrink_timer;
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
OwnPtr<Gfx::SharedImageBuffer> m_backup_shared_image_buffer;
LibWeb: Refactor int types in WebContentServer to DevicePixels
2023-12-14 03:17:00 -03:00
Web::DevicePixelSize m_backup_bitmap_size;
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
Gfx::Color m_page_background_color { 255, 255, 255 };
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
Gfx::Color m_system_canvas_background_color { 255, 255, 255 };
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
Web::CSS::PreferredColorScheme m_preferred_color_scheme { Web::CSS::PreferredColorScheme::Auto };
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
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
bool m_should_suppress_history_for_current_load { false };
bool m_should_suppress_history_for_next_load { false };
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
size_t m_crash_count = 0;
RefPtr<Core::Timer> m_repeated_crash_timer;
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
RefPtr<Core::Promise<LexicalPath>> m_pending_screenshot;
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
RefPtr<Core::Promise<String>> m_pending_info_request;
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+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
Web::HTML::VisibilityState m_system_visibility_state { Web::HTML::VisibilityState::Hidden };
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
Web::HTML::AudioPlayState m_audio_play_state { Web::HTML::AudioPlayState::Paused };
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
size_t m_number_of_elements_playing_audio { 0 };
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
Web::HTML::MuteState m_mute_state { Web::HTML::MuteState::Unmuted };
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: 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
struct PendingSessionHistoryNavigation {
enum class WebContentRestoreMode : u8 {
PreserveCurrentProcessState,
RestoreFromUIProcess,
};
URL::URL url;
TraversableSessionHistory previous_session_history;
WebContentRestoreMode web_content_restore_mode { WebContentRestoreMode::PreserveCurrentProcessState };
};
static StringView pending_session_history_navigation_web_content_restore_mode_to_string(PendingSessionHistoryNavigation::WebContentRestoreMode);
struct PendingWebContentSessionHistorySeed {
bool should_send_entries { false };
bool ignore_updates_until_seed { false };
bool waiting_for_ack { false };
bool should_reseed_after_current_history_load { false };
Optional<i32> step_after_loading_top_level_entry;
void clear() { *this = {}; }
};
struct PendingSessionHistoryTraversal {
enum class Stage : u8 {
ApplyingInWebContent,
CheckingCancelation,
LoadingEntryFromUIProcess,
ReplacingWebContentProcess,
RestoringNestedStepAfterSeed,
};
i32 target_step { 0 };
size_t target_step_index { 0 };
u64 cancelation_check_request_id { 0 };
bool will_change_top_level_entry { false };
bool will_replace_web_content_process { false };
Stage stage { Stage::ApplyingInWebContent };
Function<void(HistoryTraversalOutcome)> on_cancelation_check_complete;
};
static StringView pending_session_history_traversal_stage_to_string(PendingSessionHistoryTraversal::Stage);
TraversableSessionHistory m_session_history;
bool m_current_web_content_session_history_matches_mirror { false };
Optional<PendingSessionHistoryNavigation> m_pending_session_history_navigation;
Optional<PendingSessionHistoryTraversal> m_pending_session_history_traversal;
u64 m_next_traverse_history_step_cancelation_check_request_id { 0 };
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
Optional<URL::URL> m_session_history_entry_url_loading_from_ui_process;
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
PendingWebContentSessionHistorySeed m_pending_web_content_session_history_seed;
Optional<URL::URL> m_webdriver_pending_navigation_url;
bool m_webdriver_pending_navigation_completes_with_session_history_update { false };
RefPtr<Core::Promise<Empty>> m_pending_session_history_reset_for_testing;
struct WebDriverNavigationCompletionRequest {
Function<void(Web::WebDriver::Response)> on_complete;
RefPtr<Core::Timer> timer;
u64 navigation_listener_id { 0 };
};
u64 m_next_webdriver_navigation_completion_request_id { 0 };
HashMap<u64, OwnPtr<WebDriverNavigationCompletionRequest>> m_pending_webdriver_navigation_completion_requests;
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
// Most recent caret position pushed by WebContent, Used for placing platform IME overlays without a sync IPC.
Optional<Web::DevicePixelRect> m_input_caret_rect;
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
Web::ViewportIsFullscreen m_is_fullscreen { Web::ViewportIsFullscreen::No };
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
Core::AnonymousBuffer m_document_cookie_version_buffer;
HashMap<String, Core::SharedVersionIndex> m_document_cookie_version_indices;
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
DevTools::DevToolsDelegate::OnHostCookieChange m_on_host_cookie_change;
LibDevTools+LibWeb: Send IndexedDB change updates The Storage panel expects storesUpdate messages after watched storage changes. Summarize committed IndexedDB mutation logs into DevTools paths and forward them through WebContent so Firefox can refresh database, object-store, and record rows without polling. Firefox's behaviour is less than ideal here. A lot of things don't update automatically even inspecting a page in Firefox. Some things (like new databases) won't show up until you fully refresh the page. So that makes it a bit hard to know that we're doing things correctly. As far as I can tell, we are at least behaving as well as Firefox requires. We do have one workaround: Firefox doesn't display record updates without a manual refresh, and in fact any change messages for them show up as rows in the host's database table. So for now, we filter them out to avoid visual weirdness in the inspector.
2026-06-11 12:51:05 -03:00
HashMap<u64, DevTools::DevToolsDelegate::OnIndexedDatabaseChange> m_indexed_database_change_listeners;
u64 m_next_indexed_database_change_listener_id { 1 };
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
HashMap<u64, DevTools::DevToolsDelegate::OnStorageChange> m_storage_change_listeners;
u64 m_next_storage_change_listener_id { 1 };
LibDevTools+LibWeb: Show IndexedDB in DevTools Firefox asks the storage watcher for an indexed-db resource before it shows IndexedDB entries in the Storage panel. Add an IndexedDB actor and serialize the live LibWeb database registry on demand, so WebContent can return the host tree and table rows without duplicating database state. Use the LibWeb inspection helpers to read IndexedDB internals, and keep the Firefox protocol shape in LibDevTools. WebContent only forwards the serialized response over the existing DevTools IPC path.
2026-06-17 08:39:37 -03:00
HashMap<u64, DevTools::DevToolsDelegate::OnIndexedDBInspectionComplete> m_pending_indexed_database_inspection_requests;
u64 m_next_indexed_database_inspection_request_id { 1 };
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
// FIXME: Reconcile this ID with `page_id`. The latter is only unique per WebContent connection, whereas the view ID
// is required to be globally unique for Firefox DevTools.
u64 m_view_id { 0 };
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
HashMap<u64, NavigationListener> m_navigation_listeners;
u64 m_next_navigation_listener_id { 1 };
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
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
enum class NodePickerRequestType : u8 {
Hovered,
Picked,
Previewed,
};
void request_node_picker_hit_test(NodePickerRequestType, Web::DevicePixelPoint);
void did_receive_node_picker_hit_test(u64 request_id, Web::UniqueNodeID);
LibDevTools+LibWeb: Show IndexedDB in DevTools Firefox asks the storage watcher for an indexed-db resource before it shows IndexedDB entries in the Storage panel. Add an IndexedDB actor and serialize the live LibWeb database registry on demand, so WebContent can return the host tree and table rows without duplicating database state. Use the LibWeb inspection helpers to read IndexedDB internals, and keep the Firefox protocol shape in LibDevTools. WebContent only forwards the serialized response over the existing DevTools IPC path.
2026-06-17 08:39:37 -03:00
void did_receive_indexed_database_inspection(u64 request_id, JsonObject);
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
bool m_node_picker_active { false };
Optional<Web::UniqueNodeID> m_node_picker_hovered_node_id;
u64 m_next_node_picker_request_id { 1 };
HashMap<u64, NodePickerRequestType> m_pending_node_picker_requests;
DevTools::DevToolsDelegate::OnNodePickerEvent m_on_node_picker_event;
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
bool m_devtools_connected { false };
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
bool m_needs_beforeunload_check { true };
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 09:32:17 -03:00
};
}
Reference in a new issue Copy permalink