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

251 lines
18 KiB
C
Raw Permalink Normal View History

WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 12:31:42 -03:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 08:19:50 -03:00
* Copyright (c) 2020-2021, Andreas Kling <andreas@ladybird.org>
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 12:31:42 -03:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 05:24:48 -03:00
* SPDX-License-Identifier: BSD-2-Clause
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 12:31:42 -03:00
*/
#pragma once
#include <AK/HashMap.h>
LibWebView: Use NonnullRawPtr for registered views These pointers are always non-null.
2026-01-30 05:08:55 -03:00
#include <AK/NonnullRawPtr.h>
LibWebView: Persist page metadata in history Record visits as soon as a page produces useful metadata such as a title or favicon so pages that never finish loading still become autocomplete candidates. Store favicons in the history schema from the start instead of introducing an upgrade path inside this series, and cover persisted metadata behavior in TestHistoryStore.
2026-04-11 19:33:00 -03:00
#include <AK/Optional.h>
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
#include <AK/RefPtr.h>
LibWebView: Reduce IPC boilerplate within the chrome process Add a small helper function to find the view / log when the view cannot be found.
2024-03-29 10:44:49 -03:00
#include <AK/SourceLocation.h>
LibWebView: Persist page metadata in history Record visits as soon as a page produces useful metadata such as a title or favicon so pages that never finish loading still become autocomplete candidates. Store favicons in the history schema from the start instead of introducing an upgrade path inside this series, and cover persisted metadata behavior in TestHistoryStore.
2026-04-11 19:33:00 -03:00
#include <AK/String.h>
#include <AK/StringView.h>
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
#include <LibCore/Forward.h>
LibWeb+LibWebView: Feed async scroll deltas in device pixels The synchronous wheel path treats wheel deltas as CSS-pixel scroll distances, while the async compositor scroll tree mutates scroll state stored in device pixels. Passing the same unscaled delta into the compositor made async scrolling advance too little whenever device pixels per CSSPixel was greater than 1, so scrolling felt slower than with async scrolling disabled. Convert wheel deltas before crossing the compositor boundary and make the compositor IPC carry only the device-pixel position and delta it needs. This keeps AsyncScrollTree device-pixel native and makes async viewport scrolling match the synchronous path across high-DPI displays and page zoom levels.
2026-05-12 14:38:29 -03:00
#include <LibGfx/Point.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>
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>
Userland: Rename IPC::ServerConnection=>IPC::ConnectionToServer This was done with CLion's automatic rename feature.
2022-02-25 07:27:37 -03:00
#include <LibIPC/ConnectionToServer.h>
LibIPC+Everywhere: Introduce an IPC Transport abstraction This abstraction will help us to support multiple IPC transport mechanisms going forward. For now, we only have a TransportSocket that implements the same behavior we previously had, using Unix Sockets for IPC.
2024-10-22 18:47:33 -03:00
#include <LibIPC/Transport.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 <LibRequests/NetworkError.h>
#include <LibRequests/RequestTimingInfo.h>
LibWeb+LibWebView+Services: Add IPC for starting WebWorker of a type The provides some of the plumbing for a WebContent process to spin up a WebWorker that is not just a dedicated worker.
2025-04-24 02:07:09 -03:00
#include <LibWeb/Bindings/MainThreadVM.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>
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
#include <LibWeb/CSS/StyleSheetIdentifier.h>
LibWebView+WebContent: Allocate compositor contexts in Browser The helper process is a Browser-owned singleton, so Browser has to be the source of truth for which contexts exist: it is the only party that can register them with the helper, route backing-store and presentation upcalls back to the right WebContent and page, and reap them when a WebContent crashes. Move id allocation into Browser and have WebContent ask for ids over IPC, so the runtime switch in the next commit only has to select the backend. Behavior is preserved because Browser reproduces the previous deterministic-vs-fresh allocation logic and the in-process compositor still owns rendering.
2026-05-22 09:15:34 -03:00
#include <LibWeb/Compositor/Types.h>
LibWeb: Handle viewport scrollbar drags in the compositor Route mouse events over the compositor IPC path while async scrolling is enabled, and let the compositor capture viewport scrollbar drags before the main-thread event path sees them. Dragging mutates the compositor scroll tree and schedules an async-scroll present, so the viewport thumb and content can move without a main-thread round trip. Keep normal main-thread event handling for misses and preserve the wheel bypass behavior for page events.
2026-05-12 16:49:42 -03:00
#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>
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>
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/HTML/SessionHistoryEntry.h>
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
#include <LibWeb/HTML/WebViewHints.h>
LibWebView+WebContent+WebWorker: Move worker ownership into LibWebView This lays the groundwork to allow shared workers, nested workers (i.e. workers owned by workers) and service workers to function independently of WebContent.
2026-05-21 10:33:23 -03:00
#include <LibWeb/HTML/WorkerAgentTypes.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>
Everywhere: Implement persistence of localStorage using sqlite This change follows the pattern of our cookies persistence implementation: the "browser" process is responsible for interacting with the sqlite database, and WebContent communicates all storage operations via IPC. The new database table uses (storage_endpoint, storage_key, bottle_key) as the primary key. This design follows concepts from the https://storage.spec.whatwg.org/ and is intended to support reuse of the persistence layer for other APIs (e.g., CacheStorage, IndexedDB). For now, `storage_endpoint` is always "localStorage", `storage_key` is the website's origin, and `bottle_key` is the name of the localStorage key.
2025-06-08 18:35:46 -03:00
#include <LibWeb/StorageAPI/StorageEndpoint.h>
LibWebView: Create a spare WebContent process Since cross-site navigation is a pretty frequent task, creating a spare process is commonplace in other browsers to reduce the overhead of directing the target site to a new process. We store this process on the WebView application. If it is unavailable, we queue a task to create it later.
2025-03-09 19:01:25 -03:00
#include <LibWebView/Forward.h>
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 12:31:42 -03:00
#include <WebContent/WebContentClientEndpoint.h>
#include <WebContent/WebContentServerEndpoint.h>
LibWebView: Move OutOfProcessWebView to a new LibWebView library Also moves WebContentClient and the references to the generated IPC descriptions, since they are all components of OutOfProcessWebView. This patch has no functional changes.
2022-04-30 05:46:33 -03:00
namespace WebView {
LibWeb: Move OutOfProcessWebView into the Web namespace
2020-08-24 08:03:18 -03:00
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
class ViewImplementation;
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 12:31:42 -03:00
LibWebView: Enable EXPLICIT_SYMBOL_EXPORT
2025-07-02 00:55:11 -03:00
class WEBVIEW_API WebContentClient final
Userland: Rename IPC::ServerConnection=>IPC::ConnectionToServer This was done with CLion's automatic rename feature.
2022-02-25 07:27:37 -03:00
: public IPC::ConnectionToServer<WebContentClientEndpoint, WebContentServerEndpoint>
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 12:31:42 -03:00
, public WebContentClientEndpoint {
LibIPC: Remove socket path from IPC Client connections We don't need these for Ladybird, and they are the only users of some LibCore functions we can remove as well.
2024-11-21 16:46:45 -03:00
C_OBJECT_ABSTRACT(WebContentClient);
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 12:31:42 -03:00
public:
LibWebView+ImageDecoder+RequestServer+WebContent: Add init_transport
2025-01-03 13:19:46 -03:00
using InitTransport = Messages::WebContentServer::InitTransport;
LibWebView: Allow querying and iterating all extant WebContentClients This is mostly useful when some application-level logic needs to iterate over all child processes. A more robust Process abstraction would make this easier.
2024-06-26 16:43:45 -03:00
template<CallableAs<IterationDecision, WebContentClient&> Callback>
static void for_each_client(Callback callback);
Meta: Enable exit-time destructor warnings for libraries Enable -Wexit-time-destructors for all in-tree library targets and update process-lifetime library statics so they no longer register exit-time destructors. Long-lived caches, lookup tables, singleton registries, and generated constants now use NeverDestroyed or leaked references where the data is intended to live until process exit. Update LibWeb, LibLine, and the binding generators so regenerated sources follow the same rule instead of reintroducing destructed statics.
2026-06-04 05:40:32 -03:00
static size_t client_count() { return clients().size(); }
LibWebView+WebContent: Allocate compositor contexts in Browser The helper process is a Browser-owned singleton, so Browser has to be the source of truth for which contexts exist: it is the only party that can register them with the helper, route backing-store and presentation upcalls back to the right WebContent and page, and reap them when a WebContent crashes. Move id allocation into Browser and have WebContent ask for ids over IPC, so the runtime switch in the next commit only has to select the backend. Behavior is preserved because Browser reproduces the previous deterministic-vs-fresh allocation logic and the in-process compositor still owns rendering.
2026-05-22 09:15:34 -03:00
static Optional<WebContentClient&> client_for_compositor_context_id(Web::Compositor::CompositorContextId);
LibWebView+WebContent: Make page IDs browser-assigned Page IDs were allocated independently by each WebContent PageHost, starting at zero for every process. That made them unsuitable as a global identity for page-presenting compositor contexts, because the same numeric page ID could exist in multiple WebContent processes. Move page ID allocation to WebView::Application and initialize each WebContent process with its browser-assigned first page ID over IPC. New view requests now get a browser-assigned page ID before WebContent creates the PageClient, and PageHost no longer owns a local page counter. This gives page-presenting compositor contexts a stable global page identity, which will allow their context IDs to be derived from page IDs and simplify compositor context allocation in a follow-up.
2026-05-30 11:58:13 -03:00
WebContentClient(NonnullOwnPtr<IPC::Transport>, u64 initial_page_id);
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
~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
LibWebView: Create a spare WebContent process Since cross-site navigation is a pretty frequent task, creating a spare process is commonplace in other browsers to reduce the overhead of directing the target site to a new process. We store this process on the WebView application. If it is unavailable, we queue a task to create it later.
2025-03-09 19:01:25 -03:00
void assign_view(Badge<Application>, ViewImplementation&);
Compositor+LibWebView+WebContent: Scaffold opt-in Compositor process The compositor is moving into a dedicated helper process. That requires a process to launch, channels for Browser and WebContent to talk to it over, and client proxies on each side. Land all of that as an inert scaffold first, gated behind --enable-compositor-process, so the default rendering path is unchanged and later commits can fill in the protocol, the service-side state, and the runtime switch against a stable target.
2026-05-22 11:02:42 -03:00
void set_compositor_connection_id(Badge<Application>, i32);
Optional<i32> compositor_connection_id(Badge<Application>) const { return m_compositor_connection_id; }
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
void register_view(u64 page_id, ViewImplementation&);
void unregister_view(u64 page_id);
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 prepare_for_detached_close(u64 page_id);
void request_close(u64 page_id);
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
LibWeb+LibWebView+WebContent: Introduce a WebUI framework When we build internal pages (e.g. about:settings), there is currently quite a lot of boilerplate needed to communicate between the browser and the page. This includes creating IDL for the page and the IPC for every message sent between the processes. These internal pages are also special in that they have privileged access to and control over the browser process. The framework introduced here serves to ease the setup of new internal pages and to reduce the access that WebContent processes have to the browser process. WebUI pages can send requests to the browser process via a `ladybird.sendMessage` API. Responses from the browser are passed through a WebUIMessage event. So, for example, an internal page may: ladybird.sendMessage("getDataFor", { id: 123 }); document.addEventListener("WebUIMessage", event => { if (event.name === "gotData") { console.assert(event.data.id === 123); } }); To handle these messages, we set up a new IPC connection between the browser and WebContent processes. This connection is torn down when the user navigates away from the internal page.
2025-03-24 10:27:36 -03:00
void web_ui_disconnected(Badge<WebUI>);
LibWebView: Report active clean WebContent exits as crashes Only treat a clean WebContent exit as intentional when the process no longer has any attached views. If WebContent exits with status 0 while a view is still attached, notify that view just like any other renderer crash so test-web can complete the active test instead of leaving it unresolved. Also mark the Unix-only exit status parameter as used on Windows, where we cannot decode a wait status.
2026-05-12 15:30:08 -03:00
bool has_views() const { return !m_views.is_empty(); }
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
void notify_all_views_of_crash();
LibWeb+LibWebView+WebContent: Recover after Compositor process crashes The browser previously treated the out-of-process Compositor as fatal. Restart the shared Compositor from the browser process, reconnect process-backed WebContent clients, recreate compositor contexts, restore viewport state, and ask WebContent to repaint and republish canvas and media resources. WebContent now marks its compositor connection lost, returns conservative values for synchronous compositor queries while reconnecting, and drops outgoing updates until the replacement transport arrives. Synchronous input queries through the compositor control connection now use fallible IPC. If the Compositor exits after the open check or before the sync reply arrives, scroll and mouse handling report that the Compositor did not handle the event and let the normal WebContent fallback run. Mouse events queued while the Compositor is unavailable now fall back to direct WebContent dispatch. This keeps input completion in step with the pending-event queue. Recovery is capped at three automatic restarts. If the restart limit is exceeded, if restart, reconnect, or context recreation fails, or if the replacement Compositor exits during active recovery, the browser crashes instead of switching process-backed views to a fallback path.
2026-05-23 22:36:24 -03:00
ErrorOr<void> reconnect_to_compositor_process(Badge<Application>);
ErrorOr<void> recreate_compositor_contexts(Badge<Application>);
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
void replay_compositor_view_state_after_reconnect(Badge<Application>);
LibWeb+LibWebView+WebContent: Recover after Compositor process crashes The browser previously treated the out-of-process Compositor as fatal. Restart the shared Compositor from the browser process, reconnect process-backed WebContent clients, recreate compositor contexts, restore viewport state, and ask WebContent to repaint and republish canvas and media resources. WebContent now marks its compositor connection lost, returns conservative values for synchronous compositor queries while reconnecting, and drops outgoing updates until the replacement transport arrives. Synchronous input queries through the compositor control connection now use fallible IPC. If the Compositor exits after the open check or before the sync reply arrives, scroll and mouse handling report that the Compositor did not handle the event and let the normal WebContent fallback run. Mouse events queued while the Compositor is unavailable now fall back to direct WebContent dispatch. This keeps input completion in step with the pending-event queue. Recovery is capped at three automatic restarts. If the restart limit is exceeded, if restart, reconnect, or context recreation fails, or if the replacement Compositor exits during active recovery, the browser crashes instead of switching process-backed views to a fallback path.
2026-05-23 22:36:24 -03:00
void notify_compositor_process_reconnected(Badge<Application>);
LibWebView+WebContent: Allocate compositor contexts in Browser The helper process is a Browser-owned singleton, so Browser has to be the source of truth for which contexts exist: it is the only party that can register them with the helper, route backing-store and presentation upcalls back to the right WebContent and page, and reap them when a WebContent crashes. Move id allocation into Browser and have WebContent ask for ids over IPC, so the runtime switch in the next commit only has to select the backend. Behavior is preserved because Browser reproduces the previous deterministic-vs-fresh allocation logic and the in-process compositor still owns rendering.
2026-05-22 09:15:34 -03:00
Web::Compositor::CompositorContextId compositor_context_id_for_page(u64 page_id);
Optional<u64> page_id_for_compositor_context_id(Web::Compositor::CompositorContextId) const;
LibWeb+LibWebView: Feed async scroll deltas in device pixels The synchronous wheel path treats wheel deltas as CSS-pixel scroll distances, while the async compositor scroll tree mutates scroll state stored in device pixels. Passing the same unscaled delta into the compositor made async scrolling advance too little whenever device pixels per CSSPixel was greater than 1, so scrolling felt slower than with async scrolling disabled. Convert wheel deltas before crossing the compositor boundary and make the compositor IPC carry only the device-pixel position and delta it needs. This keeps AsyncScrollTree device-pixel native and makes async viewport scrolling match the synchronous path across high-DPI displays and page zoom levels.
2026-05-12 14:38:29 -03:00
bool send_async_scroll_to_compositor(u64 page_id, Gfx::FloatPoint position, Gfx::FloatPoint delta_in_device_pixels);
LibWebView+WebContent: Add feature-gated Compositor process backend We are moving toward an architecture where the browser owns a single process that holds the GPU context, so Skia resources can be shared across every renderer and WebContent processes can be sandboxed away from direct GPU access. A dedicated Compositor helper process is the first step. The earlier commits laid the foundation; this one turns the helper on as a selectable backend, gated behind --enable-compositor-process so the existing in-process path stays the shipping default. Default topology -- one compositor per WebContent, in-process: +---------+ | Browser | +---------+ / | \ v v v +---+ +---+ +---+ each WebContent runs its own |WC | |WC | |WC | CompositorThread on a dedicated |+C+| |+C+| |+C+| thread, with its own GPU context. +---+ +---+ +---+ Opt-in topology -- one single-threaded Compositor, shared by all WCs: +---------+ control +-------------------+ | Browser |<----------->| Compositor | +---------+ | (single thread, | / | \ | single GPU ctx, | v v v data | shared by all | [WC] [WC] [WC] ---------->| connected WCs) | +-------------------+ Three IPC channels carry the work in the opt-in topology. The existing Browser<->WebContent channel gains context allocation. A new Browser<->Compositor channel carries context lifetime, viewport, UI input, and presentation acks plus backing-store and frame upcalls. A new WebContent<->Compositor channel carries display lists, scroll state, video, compositor surfaces, async scrolling, presentation, and screenshots, with upcalls for delegated input and compositor loss.
2026-05-22 11:17:27 -03:00
bool handle_mouse_event_in_compositor(u64 page_id, Web::MouseEvent const&);
Compositor: Handle pinch zoom asynchronously Apply pinch zoom deltas to the compositor's visual viewport transform so the currently presented display list can respond without waiting for the WebContent main thread. Keep the normal WebContent pinch event path so the real VisualViewport state and DOM-visible events catch up after. Only take the compositor path when async scrolling is enabled and there are no blocking wheel listeners, since pinch zoom dispatches a synthetic wheel event that script may cancel. Coalesce queued pinch events in WebContent so main-thread catch-up can adopt multiple gesture deltas together. Use the compositor visual viewport transform for wheel hit testing and consume wheel deltas as visual viewport pan while zoomed. Scale the handoff to layout viewport scrolling by the inverse visual viewport scale, so touchpad momentum does not jump when the visual viewport hits an edge.
2026-06-14 16:30:28 -03:00
bool handle_pinch_event_in_compositor(u64 page_id, Web::PinchEvent const&);
LibWebView+WebContent: Add feature-gated Compositor process backend We are moving toward an architecture where the browser owns a single process that holds the GPU context, so Skia resources can be shared across every renderer and WebContent processes can be sandboxed away from direct GPU access. A dedicated Compositor helper process is the first step. The earlier commits laid the foundation; this one turns the helper on as a selectable backend, gated behind --enable-compositor-process so the existing in-process path stays the shipping default. Default topology -- one compositor per WebContent, in-process: +---------+ | Browser | +---------+ / | \ v v v +---+ +---+ +---+ each WebContent runs its own |WC | |WC | |WC | CompositorThread on a dedicated |+C+| |+C+| |+C+| thread, with its own GPU context. +---+ +---+ +---+ Opt-in topology -- one single-threaded Compositor, shared by all WCs: +---------+ control +-------------------+ | Browser |<----------->| Compositor | +---------+ | (single thread, | / | \ | single GPU ctx, | v v v data | shared by all | [WC] [WC] [WC] ---------->| connected WCs) | +-------------------+ Three IPC channels carry the work in the opt-in topology. The existing Browser<->WebContent channel gains context allocation. A new Browser<->Compositor channel carries context lifetime, viewport, UI input, and presentation acks plus backing-store and frame upcalls. A new WebContent<->Compositor channel carries display lists, scroll state, video, compositor surfaces, async scrolling, presentation, and screenshots, with upcalls for delegated input and compositor loss.
2026-05-22 11:17:27 -03:00
void dispatch_mouse_event_to_web_content(u64 page_id, Web::MouseEvent const&);
LibWeb: Present frames through Compositor IPC Introduce a dedicated Compositor IPC channel between the UI process and WebContent. Use it for backing-store setup, presented bitmap delivery, and bitmap-specific ready_to_paint acknowledgements. This makes CompositorThread the single owner of frame presentation bookkeeping before async scrolling starts producing frames without the main thread. Remove old paint and backing-store messages from WebContentClient and PageClient so the UI process no longer observes two presentation protocols.
2026-05-11 16:02:29 -03:00
void notify_presented_bitmap_ready_to_paint(u64 page_id, i32 bitmap_id);
void did_present_backing_stores(u64 page_id, i32 front_bitmap_id, Gfx::SharedImage front_backing_store, i32 back_bitmap_id, Gfx::SharedImage back_backing_store);
void did_present_bitmap(u64 page_id, Gfx::IntRect, i32 bitmap_id);
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 14:20:40 -03:00
LibWebView: Create a spare WebContent process Since cross-site navigation is a pretty frequent task, creating a spare process is commonplace in other browsers to reduce the overhead of directing the target site to a new process. We store this process on the WebView application. If it is unavailable, we queue a task to create it later.
2025-03-09 19:01:25 -03:00
pid_t pid() const { return m_process_handle.pid; }
Everywhere: Hand pid of new process to client in launch_server_process() Allows WebContentClient to get pid of WebContent process right after creation, so there is no window between forking and notify_process_information() IPC response, when client doesn't know the pid.
2024-06-18 13:11:51 -03:00
void set_pid(pid_t pid) { m_process_handle.pid = pid; }
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 12:31:42 -03:00
private:
LibWebView: Persist page metadata in history Record visits as soon as a page produces useful metadata such as a title or favicon so pages that never finish loading still become autocomplete candidates. Store favicons in the history schema from the start instead of introducing an upgrade path inside this series, and cover persisted metadata behavior in TestHistoryStore.
2026-04-11 19:33:00 -03:00
void maybe_record_history_visit_for_current_load(u64 page_id, URL::URL const&, Optional<String> title, StringView reason);
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 close_server_if_unused();
LibWebView+WebContent: Allocate compositor contexts in Browser The helper process is a Browser-owned singleton, so Browser has to be the source of truth for which contexts exist: it is the only party that can register them with the helper, route backing-store and presentation upcalls back to the right WebContent and page, and reap them when a WebContent crashes. Move id allocation into Browser and have WebContent ask for ids over IPC, so the runtime switch in the next commit only has to select the backend. Behavior is preserved because Browser reproduces the previous deterministic-vs-fresh allocation logic and the in-process compositor still owns rendering.
2026-05-22 09:15:34 -03:00
bool forget_compositor_context(Web::Compositor::CompositorContextId);
void destroy_all_compositor_contexts();
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 14:20:40 -03:00
virtual void die() override;
LibWebView+WebContent: Allocate compositor contexts in Browser The helper process is a Browser-owned singleton, so Browser has to be the source of truth for which contexts exist: it is the only party that can register them with the helper, route backing-store and presentation upcalls back to the right WebContent and page, and reap them when a WebContent crashes. Move id allocation into Browser and have WebContent ask for ids over IPC, so the runtime switch in the next commit only has to select the backend. Behavior is preserved because Browser reproduces the previous deterministic-vs-fresh allocation logic and the in-process compositor still owns rendering.
2026-05-22 09:15:34 -03:00
virtual Messages::WebContentClient::AllocateCompositorContextIdResponse allocate_compositor_context_id(u64 page_id, Web::Compositor::PagePresentationRegistration) override;
LibWebView+WebContent: Add feature-gated Compositor process backend We are moving toward an architecture where the browser owns a single process that holds the GPU context, so Skia resources can be shared across every renderer and WebContent processes can be sandboxed away from direct GPU access. A dedicated Compositor helper process is the first step. The earlier commits laid the foundation; this one turns the helper on as a selectable backend, gated behind --enable-compositor-process so the existing in-process path stays the shipping default. Default topology -- one compositor per WebContent, in-process: +---------+ | Browser | +---------+ / | \ v v v +---+ +---+ +---+ each WebContent runs its own |WC | |WC | |WC | CompositorThread on a dedicated |+C+| |+C+| |+C+| thread, with its own GPU context. +---+ +---+ +---+ Opt-in topology -- one single-threaded Compositor, shared by all WCs: +---------+ control +-------------------+ | Browser |<----------->| Compositor | +---------+ | (single thread, | / | \ | single GPU ctx, | v v v data | shared by all | [WC] [WC] [WC] ---------->| connected WCs) | +-------------------+ Three IPC channels carry the work in the opt-in topology. The existing Browser<->WebContent channel gains context allocation. A new Browser<->Compositor channel carries context lifetime, viewport, UI input, and presentation acks plus backing-store and frame upcalls. A new WebContent<->Compositor channel carries display lists, scroll state, video, compositor surfaces, async scrolling, presentation, and screenshots, with upcalls for delegated input and compositor loss.
2026-05-22 11:17:27 -03:00
virtual void did_destroy_compositor_context(Web::Compositor::CompositorContextId) override;
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 void did_request_new_process_for_navigation(u64 page_id, URL::URL url, Variant<Empty, String, Web::HTML::POSTResource> document_resource, Web::Bindings::NavigationHistoryBehavior history_handling) override;
virtual void did_start_webdriver_navigation(u64 page_id, URL::URL url) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual void did_finish_loading(u64 page_id, URL::URL) override;
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 void did_request_refresh(u64 page_id) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual void did_request_cursor_change(u64 page_id, Gfx::Cursor) override;
LibWeb+LibWebView+WebContent+UI: Port the document title to UTF-16
2025-07-28 17:51:01 -03:00
virtual void did_change_title(u64 page_id, Utf16String) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual void did_change_url(u64 page_id, URL::URL) override;
virtual void did_request_tooltip_override(u64 page_id, Gfx::IntPoint, ByteString) override;
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
virtual void did_stop_tooltip_override(u64 page_id) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual void did_enter_tooltip_area(u64 page_id, ByteString) override;
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 void did_leave_tooltip_area(u64 page_id) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual void did_hover_link(u64 page_id, URL::URL) override;
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 void did_unhover_link(u64 page_id) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual void did_click_link(u64 page_id, URL::URL, ByteString, unsigned) override;
virtual void did_middle_click_link(u64 page_id, URL::URL, ByteString, unsigned) override;
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 void did_start_loading(u64 page_id, URL::URL, Variant<Empty, String, Web::HTML::POSTResource>, bool, Web::Bindings::NavigationHistoryBehavior) override;
virtual void did_cancel_loading(u64 page_id, URL::URL) override;
LibWeb+LibWebView+WebContent+UI: Add an action to cut text
2026-05-06 13:00:59 -03:00
virtual void did_request_context_menu(u64 page_id, Gfx::IntPoint, Web::ContextMenuForInputEventsTarget) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual void did_request_link_context_menu(u64 page_id, Gfx::IntPoint, URL::URL, ByteString, unsigned) override;
virtual void did_request_image_context_menu(u64 page_id, Gfx::IntPoint, URL::URL, ByteString, unsigned, Optional<Gfx::ShareableBitmap>) override;
virtual void did_request_media_context_menu(u64 page_id, Gfx::IntPoint, ByteString, unsigned, Web::Page::MediaContextMenu) override;
virtual void did_get_source(u64 page_id, URL::URL, URL::URL, String) override;
virtual void did_inspect_dom_tree(u64 page_id, String) override;
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
virtual void did_inspect_storage(u64 page_id, u64 request_id, String) override;
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
virtual void did_inspect_dom_node(u64 page_id, DOMNodeProperties) override;
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
virtual void did_inspect_grid_layouts(u64 page_id, String) override;
virtual void did_inspect_current_grid(u64 page_id, String) override;
WebContent+LibWebView: Add flexbox inspection plumbing
2026-05-27 12:41:13 -03:00
virtual void did_inspect_current_flexbox(u64 page_id, String) override;
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
virtual void did_inspect_indexed_database(u64 page_id, u64 request_id, String) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual void did_inspect_accessibility_tree(u64 page_id, String) override;
virtual void did_get_hovered_node_id(u64 page_id, Web::UniqueNodeID node_id) override;
LibWeb+WebContent: Add node picker hit testing Picking needs hit testing in the page process, where layout and event targeting state live. Expose a small page-level query and WebContent IPC entry point that returns the node id at a viewport position. This lets DevTools ask WebContent what the picker is pointing at without duplicating hit-test logic outside LibWeb.
2026-05-28 08:10:27 -03:00
virtual void did_get_node_id_at_position(u64 page_id, u64 request_id, Web::UniqueNodeID node_id) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual void did_finish_editing_dom_node(u64 page_id, Optional<Web::UniqueNodeID> node_id) override;
virtual void did_mutate_dom(u64 page_id, Mutation) override;
virtual void did_get_dom_node_html(u64 page_id, String html) override;
LibWeb+LibWebView+WebContent: Remove the built-in Inspector
2025-03-14 17:22:16 -03:00
virtual void did_list_style_sheets(u64 page_id, Vector<Web::CSS::StyleSheetIdentifier> stylesheets) override;
virtual void did_get_style_sheet_source(u64 page_id, Web::CSS::StyleSheetIdentifier identifier, URL::URL, String source) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual void did_take_screenshot(u64 page_id, Gfx::ShareableBitmap screenshot) override;
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
virtual void did_get_internal_page_info(u64 page_id, PageInfoType, Optional<Core::AnonymousBuffer>) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual void did_execute_js_console_input(u64 page_id, JsonValue) override;
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
virtual void did_output_js_console_message(u64 page_id, ConsoleOutput) override;
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
virtual void did_start_network_request(u64 page_id, u64 request_id, URL::URL, ByteString method, Vector<HTTP::Header>, ByteBuffer request_body, Optional<String> initiator_type) override;
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
virtual void did_receive_network_response_headers(u64 page_id, u64 request_id, u32 status_code, Optional<String> reason_phrase, Vector<HTTP::Header>) override;
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
virtual void did_receive_network_response_body(u64 page_id, u64 request_id, ByteBuffer data) override;
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
virtual void did_finish_network_request(u64 page_id, u64 request_id, u64 body_size, Requests::RequestTimingInfo, Optional<Requests::NetworkError>) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual void did_change_favicon(u64 page_id, Gfx::ShareableBitmap) override;
virtual void did_request_alert(u64 page_id, String) override;
virtual void did_request_confirm(u64 page_id, String) override;
virtual void did_request_prompt(u64 page_id, String, String) override;
virtual void did_request_set_prompt_text(u64 page_id, String message) override;
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 void did_request_accept_dialog(u64 page_id) override;
virtual void did_request_dismiss_dialog(u64 page_id) override;
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
virtual void did_request_document_cookie_version_index(u64 page_id, i64 document_id, String domain) override;
LibWeb: Implement CookieStore::get(name)
2025-08-05 17:05:45 -03:00
virtual Messages::WebContentClient::DidRequestAllCookiesWebdriverResponse did_request_all_cookies_webdriver(URL::URL) override;
virtual Messages::WebContentClient::DidRequestAllCookiesCookiestoreResponse did_request_all_cookies_cookiestore(URL::URL) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual Messages::WebContentClient::DidRequestNamedCookieResponse did_request_named_cookie(URL::URL, String) override;
LibHTTP+Everywhere: Move the cookie implementation to LibHTTP This will allow parsing cookies outside of LibWeb. LibHTTP is basically becoming the home of HTTP WG specs.
2026-02-07 13:13:47 -03:00
virtual Messages::WebContentClient::DidRequestCookieResponse did_request_cookie(u64 page_id, URL::URL, HTTP::Cookie::Source) override;
virtual void did_set_cookie(URL::URL, HTTP::Cookie::ParsedCookie, HTTP::Cookie::Source) override;
virtual void did_update_cookie(HTTP::Cookie::Cookie) override;
LibWeb+LibWebView: Add an internal API to expire cookies with an offset Cookies have a minimum expiry resolution of 1 second. So to test cookie expiration, the test had to idle for at least a second, which is quite a noticeable delay now that LibWeb tests are parallelized. Instead, we can add an internal API to expire cookies with a time offset to avoid this idle delay.
2024-10-13 09:56:46 -03:00
virtual void did_expire_cookies_with_time_offset(AK::Duration) override;
LibWebView: Add async cookie deletion internals Add Internals.deleteAllCookies(), backed by an async WebContent to browser request and ack pair. CookieJar can now clear transient and persisted cookies. Note that we only delete all cookies associated with the current URL so that tests are able to run in parallel with one another without impacting shared cookie state.
2026-06-10 12:37:14 -03:00
virtual void did_request_delete_all_cookies(u64 page_id, u64 request_id, URL::URL) override;
LibWeb+LibHTTP+LibWebView: Implement HSTS When an HTTPS response carries a Strict-Transport-Security header, the received policy is now respected. Subsequent HTTP requests to a known HSTS host are upgraded to HTTPS before the fetch algorithm makes further decisions such as CORS and mixed content. Fixes tpexpress.co.uk, where an XHR redirects HTTPS -> HTTP -> HTTPS, relying on a HSTS policy received on the document response to avoid the CORS failure.
2026-03-26 14:04:33 -03:00
virtual void did_store_hsts_policy(String, HTTP::HSTS::ParsedHSTSPolicy) override;
virtual Messages::WebContentClient::DidIsKnownHstsHostResponse did_is_known_hsts_host(String) override;
Everywhere: Implement persistence of localStorage using sqlite This change follows the pattern of our cookies persistence implementation: the "browser" process is responsible for interacting with the sqlite database, and WebContent communicates all storage operations via IPC. The new database table uses (storage_endpoint, storage_key, bottle_key) as the primary key. This design follows concepts from the https://storage.spec.whatwg.org/ and is intended to support reuse of the persistence layer for other APIs (e.g., CacheStorage, IndexedDB). For now, `storage_endpoint` is always "localStorage", `storage_key` is the website's origin, and `bottle_key` is the name of the localStorage key.
2025-06-08 18:35:46 -03:00
virtual Messages::WebContentClient::DidRequestStorageItemResponse did_request_storage_item(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key) override;
virtual Messages::WebContentClient::DidSetStorageItemResponse did_set_storage_item(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key, String value) override;
virtual void did_remove_storage_item(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key) override;
virtual Messages::WebContentClient::DidRequestStorageKeysResponse did_request_storage_keys(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key) override;
virtual void did_clear_storage(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key) override;
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
virtual void did_change_storage_item(u64 page_id, Web::StorageAPI::StorageEndpointType storage_endpoint, String url, Optional<String> key, Optional<String> old_value, Optional<String> new_value) override;
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
virtual void did_update_indexed_database(u64 page_id, String update) override;
LibWeb: Implement cross process BroadcastChannel delivery Route BroadcastChannel messages over IPC so matching channels can receive them across WebContent and WebWorker processes, rather than only within a single process. Each channel now serializes its payload, sends it upward over IPC, and receiving processes deliver it locally after matching by storage key and channel name.
2026-04-10 16:18:00 -03:00
virtual void did_post_broadcast_channel_message(u64 page_id, Web::HTML::BroadcastChannelMessage message) override;
LibWebView+WebContent: Make page IDs browser-assigned Page IDs were allocated independently by each WebContent PageHost, starting at zero for every process. That made them unsuitable as a global identity for page-presenting compositor contexts, because the same numeric page ID could exist in multiple WebContent processes. Move page ID allocation to WebView::Application and initialize each WebContent process with its browser-assigned first page ID over IPC. New view requests now get a browser-assigned page ID before WebContent creates the PageClient, and PageHost no longer owns a local page counter. This gives page-presenting compositor contexts a stable global page identity, which will allow their context IDs to be derived from page IDs and simplify compositor context allocation in a follow-up.
2026-05-30 11:58:13 -03:00
virtual Messages::WebContentClient::DidRequestNewWebViewResponse did_request_new_web_view(u64 page_id, Web::HTML::ActivateTab, Web::HTML::WebViewHints) override;
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 void did_request_activate_tab(u64 page_id) override;
virtual void did_close_browsing_context(u64 page_id) override;
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
virtual void did_change_needs_beforeunload_check(u64 page_id, bool needs_beforeunload_check) override;
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 Messages::WebContentClient::DidRequestTraverseTheHistoryByDeltaResponse did_request_traverse_the_history_by_delta(u64 page_id, i32 delta, Web::HistoryTraversalPrecheck) override;
virtual void did_request_webdriver_history_traversal(u64 page_id, u64 request_id, i32 delta) override;
virtual Messages::WebContentClient::DidRequestWebdriverLoadUrlFromUiResponse did_request_webdriver_load_url_from_ui(u64 page_id, URL::URL url) override;
virtual Messages::WebContentClient::DidRequestWebdriverTraverseHistoryFromUiResponse did_request_webdriver_traverse_history_from_ui(u64 page_id, i32 delta) override;
virtual Messages::WebContentClient::DidRequestWebdriverMarkWebContentSessionHistoryStaleResponse did_request_webdriver_mark_web_content_session_history_stale(u64 page_id) override;
virtual Messages::WebContentClient::DidRequestWebdriverSessionHistoryResponse did_request_webdriver_session_history(u64 page_id) override;
virtual void did_request_webdriver_navigation_completion(u64 page_id, u64 request_id, Optional<u64> page_load_timeout) override;
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 void did_update_resource_count(u64 page_id, i32 count_waiting) override;
virtual void did_request_restore_window(u64 page_id) override;
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
virtual void did_request_reposition_window(u64 page_id, Gfx::IntPoint) override;
virtual void did_request_resize_window(u64 page_id, Gfx::IntSize) override;
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
virtual void did_request_maximize_window(u64 page_id) override;
virtual void did_request_minimize_window(u64 page_id) override;
WebContent: Remove the sync result from did_request_fullscreen_window This was unused.
2026-03-16 19:38:31 -03:00
virtual void did_request_fullscreen_window(u64 page_id) override;
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
virtual void did_request_exit_fullscreen(u64 page_id) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual void did_request_file(u64 page_id, ByteString path, i32) override;
virtual void did_request_color_picker(u64 page_id, Color current_color) override;
virtual void did_request_file_picker(u64 page_id, Web::HTML::FileFilter accepted_file_types, Web::HTML::AllowMultipleFiles) override;
virtual void did_request_select_dropdown(u64 page_id, Gfx::IntPoint content_position, i32 minimum_width, Vector<Web::HTML::SelectItem> items) override;
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
virtual void did_finish_handling_input_event(u64 page_id, Web::EventResult event_result) override;
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
virtual void did_update_input_caret_rect(u64 page_id, Optional<Web::DevicePixelRect> rect) override;
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
virtual void did_finish_test(u64 page_id, String text) override;
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
virtual void did_set_test_timeout(u64 page_id, double milliseconds) override;
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
virtual void did_receive_reference_test_metadata(u64 page_id, JsonValue) override;
LibWeb+UI: Add internals API to set browser zoom
2024-12-23 18:15:06 -03:00
virtual void did_set_browser_zoom(u64 page_id, double factor) override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 14:22:39 -03:00
virtual void did_find_in_page(u64 page_id, size_t current_match_index, Optional<size_t> total_match_count) override;
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 void did_change_theme_color(u64 page_id, Gfx::Color color) override;
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
virtual void did_change_background_color(u64 page_id, Gfx::Color color) override;
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
virtual void did_insert_clipboard_entry(u64 page_id, Web::Clipboard::SystemClipboardRepresentation, String presentation_style) override;
virtual void did_request_clipboard_entries(u64 page_id, u64 request_id) override;
LibWeb+LibWebView+UI: Use the system selection text for primary pasting Commit 218d82cb65c636d1a56d6cb921ad1a4afe4f7202 added support for pasting text with the middle mouse button. But primary pasting is actually meant to interact with the "selection" clipboard, not the text clipboard.
2026-05-18 08:18:50 -03:00
virtual void did_request_primary_paste(u64 page_id) override;
LibWeb+LibWebView+UI: Update the selection keyboard on selection changes When the selected text on a page changes, update the system selection clipboard on supported systems (if primary pasting is enabled).
2026-05-27 12:43:35 -03:00
virtual void did_update_primary_selection(u64 page_id, String) override;
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
virtual void did_change_audio_play_state(u64 page_id, Web::HTML::AudioPlayState) override;
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
virtual void did_update_navigation_buttons_state(u64 page_id, bool back_enabled, bool forward_enabled) override;
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 void did_update_session_history(u64 page_id, Vector<Web::HTML::SessionHistoryEntryDescriptor>, Vector<i32>, size_t current_used_step_index) override;
virtual Messages::WebContentClient::DidRequestUiProcessSessionHistoryForTestingResponse did_request_ui_process_session_history_for_testing(u64 page_id) override;
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
virtual Messages::WebContentClient::DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTestingResponse did_update_session_history_and_request_ui_process_session_history_for_testing(u64 page_id, Vector<Web::HTML::SessionHistoryEntryDescriptor>, Vector<i32>, size_t current_used_step_index) override;
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 void did_set_top_level_session_history(u64 page_id, bool accepted, Vector<Web::HTML::SessionHistoryEntryDescriptor>, Vector<i32> used_steps, size_t current_used_step_index) override;
virtual void did_traverse_the_history_to_step(u64 page_id, i32 step, bool step_was_available, Web::HTML::HistoryStepResult) override;
virtual void did_check_if_traverse_history_step_is_canceled(
u64 page_id, u64 request_id, i32 step, bool canceled) override;
virtual void did_reset_session_history_for_testing(u64 page_id) override;
LibWebView+WebContent+WebWorker: Move worker ownership into LibWebView This lays the groundwork to allow shared workers, nested workers (i.e. workers owned by workers) and service workers to function independently of WebContent.
2026-05-21 10:33:23 -03:00
virtual Messages::WebContentClient::StartWorkerAgentResponse start_worker_agent(u64 page_id, Web::HTML::WorkerAgentStartRequest request) override;
virtual void close_worker_agent(u64 page_id, Web::HTML::WorkerAgentId agent_id, Web::HTML::WorkerAgentOwnerToken owner_token) override;
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 12:31:42 -03:00
LibWebView: Reduce IPC boilerplate within the chrome process Add a small helper function to find the view / log when the view cannot be found.
2024-03-29 10:44:49 -03:00
Optional<ViewImplementation&> view_for_page_id(u64, SourceLocation = SourceLocation::current());
Compositor+LibWeb+LibWebView: Simplify compositor context IDs Page-presenting compositor contexts still carried a separate tagged ID namespace and Browser-side page/context maps even though page IDs are now allocated globally by the UI process. That made context registration keep two ways to describe the same relationship and forced compositor IPC to pass an extra presentation bit. Use each page ID directly as its page-presenting compositor context ID and allocate non-page compositor contexts from the same Browser-owned counter. The registration path now sends only the optional page ID, and Compositor infers client presentation from that page ID.
2026-05-30 12:36:06 -03:00
void remember_compositor_context(Web::Compositor::CompositorContextId, Optional<u64> page_id);
LibWeb+LibWebView+WebContent: Recover after Compositor process crashes The browser previously treated the out-of-process Compositor as fatal. Restart the shared Compositor from the browser process, reconnect process-backed WebContent clients, recreate compositor contexts, restore viewport state, and ask WebContent to repaint and republish canvas and media resources. WebContent now marks its compositor connection lost, returns conservative values for synchronous compositor queries while reconnecting, and drops outgoing updates until the replacement transport arrives. Synchronous input queries through the compositor control connection now use fallible IPC. If the Compositor exits after the open check or before the sync reply arrives, scroll and mouse handling report that the Compositor did not handle the event and let the normal WebContent fallback run. Mouse events queued while the Compositor is unavailable now fall back to direct WebContent dispatch. This keeps input completion in step with the pending-event queue. Recovery is capped at three automatic restarts. If the restart limit is exceeded, if restart, reconnect, or context recreation fails, or if the replacement Compositor exits during active recovery, the browser crashes instead of switching process-backed views to a fallback path.
2026-05-23 22:36:24 -03:00
LibWebView: Use NonnullRawPtr for registered views These pointers are always non-null.
2026-01-30 05:08:55 -03:00
HashMap<u64, NonnullRawPtr<ViewImplementation>> m_views;
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
HashTable<u64> m_detached_pages_pending_close;
Compositor+LibWeb+LibWebView: Simplify compositor context IDs Page-presenting compositor contexts still carried a separate tagged ID namespace and Browser-side page/context maps even though page IDs are now allocated globally by the UI process. That made context registration keep two ways to describe the same relationship and forced compositor IPC to pass an extra presentation bit. Use each page ID directly as its page-presenting compositor context ID and allocate non-page compositor contexts from the same Browser-owned counter. The registration path now sends only the optional page ID, and Compositor infers client presentation from that page ID.
2026-05-30 12:36:06 -03:00
HashMap<Web::Compositor::CompositorContextId, Optional<u64>> m_compositor_contexts;
LibWebView: Persist page metadata in history Record visits as soon as a page produces useful metadata such as a title or favicon so pages that never finish loading still become autocomplete candidates. Store favicons in the history schema from the start instead of introducing an upgrade path inside this series, and cover persisted metadata behavior in TestHistoryStore.
2026-04-11 19:33:00 -03:00
HashMap<u64, String> m_history_recorded_urls_for_current_load;
Compositor+LibWebView+WebContent: Scaffold opt-in Compositor process The compositor is moving into a dedicated helper process. That requires a process to launch, channels for Browser and WebContent to talk to it over, and client proxies on each side. Land all of that as an inert scaffold first, gated behind --enable-compositor-process, so the default rendering path is unchanged and later commits can fill in the protocol, the service-side state, and the runtime switch against a stable target.
2026-05-22 11:02:42 -03:00
Optional<i32> m_compositor_connection_id;
LibWebView+WebContent: Make page IDs browser-assigned Page IDs were allocated independently by each WebContent PageHost, starting at zero for every process. That made them unsuitable as a global identity for page-presenting compositor contexts, because the same numeric page ID could exist in multiple WebContent processes. Move page ID allocation to WebView::Application and initialize each WebContent process with its browser-assigned first page ID over IPC. New view requests now get a browser-assigned page ID before WebContent creates the PageClient, and PageHost no longer owns a local page counter. This gives page-presenting compositor contexts a stable global page identity, which will allow their context IDs to be derived from page IDs and simplify compositor context allocation in a follow-up.
2026-05-30 11:58:13 -03:00
u64 m_initial_page_id { 0 };
LibWebView: Display each tab's title in the Task Manager This allows us to more easily differentiate between WebContent processes in the Task Manager at a glance.
2024-04-22 15:11:46 -03:00
ProcessHandle m_process_handle;
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
RefPtr<Core::Timer> m_detached_page_close_timer;
LibWebView: Allow querying and iterating all extant WebContentClients This is mostly useful when some application-level logic needs to iterate over all child processes. A more robust Process abstraction would make this easier.
2024-06-26 16:43:45 -03:00
LibWeb+LibWebView+WebContent: Introduce a WebUI framework When we build internal pages (e.g. about:settings), there is currently quite a lot of boilerplate needed to communicate between the browser and the page. This includes creating IDL for the page and the IPC for every message sent between the processes. These internal pages are also special in that they have privileged access to and control over the browser process. The framework introduced here serves to ease the setup of new internal pages and to reduce the access that WebContent processes have to the browser process. WebUI pages can send requests to the browser process via a `ladybird.sendMessage` API. Responses from the browser are passed through a WebUIMessage event. So, for example, an internal page may: ladybird.sendMessage("getDataFor", { id: 123 }); document.addEventListener("WebUIMessage", event => { if (event.name === "gotData") { console.assert(event.data.id === 123); } }); To handle these messages, we set up a new IPC connection between the browser and WebContent processes. This connection is torn down when the user navigates away from the internal page.
2025-03-24 10:27:36 -03:00
RefPtr<WebUI> m_web_ui;
Meta: Enable exit-time destructor warnings for libraries Enable -Wexit-time-destructors for all in-tree library targets and update process-lifetime library statics so they no longer register exit-time destructors. Long-lived caches, lookup tables, singleton registries, and generated constants now use NeverDestroyed or leaked references where the data is intended to live until process exit. Update LibWeb, LibLine, and the binding generators so regenerated sources follow the same rule instead of reintroducing destructed statics.
2026-06-04 05:40:32 -03:00
static HashTable<WebContentClient*>& clients();
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 12:31:42 -03:00
};
LibWeb: Move OutOfProcessWebView into the Web namespace
2020-08-24 08:03:18 -03:00
LibWebView: Allow querying and iterating all extant WebContentClients This is mostly useful when some application-level logic needs to iterate over all child processes. A more robust Process abstraction would make this easier.
2024-06-26 16:43:45 -03:00
template<CallableAs<IterationDecision, WebContentClient&> Callback>
void WebContentClient::for_each_client(Callback callback)
{
Meta: Enable exit-time destructor warnings for libraries Enable -Wexit-time-destructors for all in-tree library targets and update process-lifetime library statics so they no longer register exit-time destructors. Long-lived caches, lookup tables, singleton registries, and generated constants now use NeverDestroyed or leaked references where the data is intended to live until process exit. Update LibWeb, LibLine, and the binding generators so regenerated sources follow the same rule instead of reintroducing destructed statics.
2026-06-04 05:40:32 -03:00
for (auto& it : clients()) {
LibWebView: Allow querying and iterating all extant WebContentClients This is mostly useful when some application-level logic needs to iterate over all child processes. A more robust Process abstraction would make this easier.
2024-06-26 16:43:45 -03:00
if (callback(*it) == IterationDecision::Break)
return;
}
}
LibWeb: Move OutOfProcessWebView into the Web namespace
2020-08-24 08:03:18 -03:00
}
Reference in a new issue Copy permalink