Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-12-08 06:09:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Services/WebContent/PageHost.cpp

510 lines
15 KiB
C++
Raw 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 17:31:42 +02:00
/*
WebContent: Fix const-correctness issues
2023-02-20 19:03:06 +01:00
* Copyright (c) 2020-2023, Andreas Kling <kling@serenityos.org>
LibWeb+WebContent: Add plumbing for 'webdriver-active flag'
2022-10-12 23:49:23 +02:00
* Copyright (c) 2021-2022, Linus Groh <linusg@serenityos.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 17:31:42 +02: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 01:24:48 -07: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 17:31:42 +02:00
*/
#include "PageHost.h"
Userland: Rename IPC ClientConnection => ConnectionFromClient This was done with CLion's automatic rename feature and with: find . -name ClientConnection.h | rename 's/ClientConnection\.h/ConnectionFromClient.h/' find . -name ClientConnection.cpp | rename 's/ClientConnection\.cpp/ConnectionFromClient.cpp/'
2022-02-25 12:18:30 +02:00
#include "ConnectionFromClient.h"
WebContent: Pass an empty bitmap object if the pointer is null Prior this commit we were always dereferencing the image bitmap pointer, even if it was null, which resulted in a crash when trying to open the context menu when an image wasn't loaded. Closes: #10178
2021-09-22 21:36:18 +02:00
#include <LibGfx/ShareableBitmap.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 17:31:42 +02:00
#include <LibGfx/SystemTheme.h>
LibWeb: Use system colors in more places
2023-08-23 17:18:33 +01:00
#include <LibWeb/CSS/SystemColor.h>
Browser+LibWeb+WebContent: Parse cookies in the OOP tab To protect the main Browser process against nefarious cookies, parse the cookies out-of-process and then send the parsed result over IPC to the main process. This way, if the cookie parser blows up, only that tab will be affected.
2021-04-15 10:36:20 -04:00
#include <LibWeb/Cookie/ParsedCookie.h>
LibWeb: Move BrowsingContext into HTML/ Browsing contexts are defined by the HTML specification, so let's move them into the HTML directory. :^)
2021-11-18 15:01:28 +01:00
#include <LibWeb/HTML/BrowsingContext.h>
LibWeb: Change viewport ownership from `BrowsingContext` to `Navigable`
2023-08-22 16:00:42 +02:00
#include <LibWeb/HTML/TraversableNavigable.h>
LibWeb: Rename Layout::InitialContainingBlock to Layout::Viewport The name "initial containing block" was wrong for this, as it doesn't correspond to the HTML element, and that's specifically what it's supposed to do! :^)
2023-02-25 11:04:29 +01:00
#include <LibWeb/Layout/Viewport.h>
LibWeb: Move PaintingBox to its own .cpp and .h files
2022-03-10 23:13:37 +01:00
#include <LibWeb/Painting/PaintableBox.h>
LibWeb/Painting: Introduce PaintingCommandExecutor Decoupling painting command executor from RecordingPainter allows to introduce painters other than CPU Gfx::Painter :)
2023-10-26 08:45:25 +02:00
#include <LibWeb/Painting/PaintingCommandExecutorCPU.h>
LibWeb: Move painting logic from Layout::Viewport to ViewportPaintable
2023-08-19 08:38:51 +02:00
#include <LibWeb/Painting/ViewportPaintable.h>
WebContent: Use Web::Platform::Timer instead of Core::Timer This will allow WebContent to operate without a Core::EventLoop.
2022-10-05 19:33:30 +02:00
#include <LibWeb/Platform/Timer.h>
WebContent: Allow the WebContent process to trigger repaints After layout, we may want to repaint the page, so we now listen for the PageClient::page_did_invalidate() notification and use it to drive a client-side repaint. Note that an invalidation request from LibWeb makes a full roundtrip to the WebContent client and back since the client drives painting.
2020-06-17 18:00:18 +02:00
#include <WebContent/WebContentClientEndpoint.h>
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
#include <WebContent/WebDriverConnection.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 17:31:42 +02:00
WebContent: Fix checking for accelerated graphics What matters here is whether or not we can use LibAccelGfx and OpenGL, not whether the kernel is Linux.
2023-11-04 20:44:22 +03:00
#ifdef HAS_ACCELERATED_GRAPHICS
Ladybird+WebContent: Add option to use GPU painter Adds `--enable-gpu-painting` param to enable painting command executor that uses LibAccelGfx.
2023-10-27 17:28:18 +02:00
# include <LibWeb/Painting/PaintingCommandExecutorGPU.h>
#endif
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 17:31:42 +02:00
namespace WebContent {
LibAccelGfx+WebContent: Use the same Painter across page repaints In the upcoming changes, Painter will be used to store the state of OpenGL context. For example, if Painter is aware of the shader that have already been loaded, it will be possible to reuse them across repaints. Also, it would be possible to manage state of loaded textures and add/remove them depending on which ones are present in the next sequence of painting commands.
2023-11-02 00:01:16 +01:00
static bool s_use_gpu_painter = false;
void PageHost::set_use_gpu_painter()
{
s_use_gpu_painter = true;
}
Userland: Rename IPC ClientConnection => ConnectionFromClient This was done with CLion's automatic rename feature and with: find . -name ClientConnection.h | rename 's/ClientConnection\.h/ConnectionFromClient.h/' find . -name ClientConnection.cpp | rename 's/ClientConnection\.cpp/ConnectionFromClient.cpp/'
2022-02-25 12:18:30 +02:00
PageHost::PageHost(ConnectionFromClient& client)
WebContent: Allow the WebContent process to trigger repaints After layout, we may want to repaint the page, so we now listen for the PageClient::page_did_invalidate() notification and use it to drive a client-side repaint. Note that an invalidation request from LibWeb makes a full roundtrip to the WebContent client and back since the client drives painting.
2020-06-17 18:00:18 +02:00
: m_client(client)
, m_page(make<Web::Page>(*this))
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 17:31:42 +02:00
{
setup_palette();
WebContent: Use Web::Platform::Timer instead of Core::Timer This will allow WebContent to operate without a Core::EventLoop.
2022-10-05 19:33:30 +02:00
m_invalidation_coalescing_timer = Web::Platform::Timer::create_single_shot(0, [this] {
LibWeb+WebContent+headless-browser: Use CSSPixels for PageClient events ...and also for hit testing, which is involved in most of them. Much of this is temporary conversions and other awkwardness, which should resolve itself as the rest of LibWeb is converted to these new types. Hopefully. :thousandyakstare:
2022-11-02 17:35:53 +00:00
m_client.async_did_invalidate_content_rect({ m_invalidation_rect.x().value(), m_invalidation_rect.y().value(), m_invalidation_rect.width().value(), m_invalidation_rect.height().value() });
WebContent: Coalesce paint invalidations to avoid spamming client Some content cause a lot of paint invalidations (e.g someone drawing to a <canvas> repeatedly) and we don't need to spam the client about this. Instead, accumulate a dirty rect, and send it once per event loop step.
2021-09-28 22:53:59 +02:00
m_invalidation_rect = {};
});
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 17:31:42 +02:00
}
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
PageHost::~PageHost() = default;
LibWeb: Plumb OOPWV focus state across the IPC boundary This makes focus outlines show up in OOPWV at last! :^)
2022-02-06 19:03:13 +01:00
void PageHost::set_has_focus(bool has_focus)
{
m_has_focus = has_focus;
}
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 17:31:42 +02:00
void PageHost::setup_palette()
{
// FIXME: Get the proper palette from our peer somehow
LibCore: Use ErrorOr<T> in Core::AnonymousBuffer
2021-11-06 01:20:51 +01:00
auto buffer_or_error = Core::AnonymousBuffer::create_with_size(sizeof(Gfx::SystemTheme));
VERIFY(!buffer_or_error.is_error());
auto buffer = buffer_or_error.release_value();
LibWeb: Port the WebContent service to Core::AnonymousBuffer for themes
2021-01-16 17:22:35 +01:00
auto* theme = buffer.data<Gfx::SystemTheme>();
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 17:31:42 +02:00
theme->color[(int)Gfx::ColorRole::Window] = Color::Magenta;
theme->color[(int)Gfx::ColorRole::WindowText] = Color::Cyan;
LibWeb: Port the WebContent service to Core::AnonymousBuffer for themes
2021-01-16 17:22:35 +01:00
m_palette_impl = Gfx::PaletteImpl::create_with_anonymous_buffer(buffer);
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 17:31:42 +02:00
}
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 15:18:42 -05:00
bool PageHost::is_connection_open() const
{
return m_client.is_open();
}
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 17:31:42 +02:00
Gfx::Palette PageHost::palette() const
{
return Gfx::Palette(*m_palette_impl);
}
WebContent: Fix const-correctness issues
2023-02-20 19:03:06 +01:00
void PageHost::set_palette_impl(Gfx::PaletteImpl& impl)
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 17:31:42 +02:00
{
m_palette_impl = impl;
WebContent: Invalidate document style when changing the page's palette This makes the page automatically update to reflect the system theme when in "Color Scheme > Follow System Theme" mode without having to manually cause a style update.
2022-07-05 17:16:50 +01:00
if (auto* document = page().top_level_browsing_context().active_document())
document->invalidate_style();
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 17:31:42 +02:00
}
LibWeb+WebContent: Add set_preferred_color_scheme IPC call This allows the owner of a WebView to override whether to use a dark theme or not, instead of just using the system theme's IsDark property.
2021-10-26 17:00:10 +01:00
void PageHost::set_preferred_color_scheme(Web::CSS::PreferredColorScheme color_scheme)
{
m_preferred_color_scheme = color_scheme;
if (auto* document = page().top_level_browsing_context().active_document())
document->invalidate_style();
}
WebContent: Add plumbing for 'is scripting enabled' setting
2022-03-30 23:23:14 +01:00
void PageHost::set_is_scripting_enabled(bool is_scripting_enabled)
{
page().set_is_scripting_enabled(is_scripting_enabled);
}
LibWeb+WebContent: Convert BrowsingContext to new pixel units This fixes a few glitches. We no longer give the page double the width it should have, and we mark the correct area of the page as needing repainting.
2022-11-03 12:49:54 +00:00
void PageHost::set_window_position(Web::DevicePixelPoint position)
LibWeb+LibWebView+WebContent: Add IPC to receive window position/size This information will have to come from the Browser application. This adds IPCs to receive that information when it is available or changes.
2022-11-01 14:55:53 -04:00
{
page().set_window_position(position);
}
LibWeb+WebContent: Convert BrowsingContext to new pixel units This fixes a few glitches. We no longer give the page double the width it should have, and we mark the correct area of the page as needing repainting.
2022-11-03 12:49:54 +00:00
void PageHost::set_window_size(Web::DevicePixelSize size)
LibWeb+LibWebView+WebContent: Add IPC to receive window position/size This information will have to come from the Browser application. This adds IPCs to receive that information when it is available or changes.
2022-11-01 14:55:53 -04:00
{
page().set_window_size(size);
}
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
ErrorOr<void> PageHost::connect_to_webdriver(DeprecatedString const& webdriver_ipc_path)
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
{
VERIFY(!m_webdriver);
LibWeb+WebContent: Virtualize methods needed for WebDriver in PageClient WebDriver currently uses the WebContent::ConnectionFromClient IPC class directly for these features. To support headless-browser, WebDriver will instead need to rely on PageClient to provide these.
2022-11-21 16:10:57 -05:00
m_webdriver = TRY(WebDriverConnection::connect(*this, webdriver_ipc_path));
WebContent+LibWebView: Consolidate the way browsers connect to WebDriver Currently, on Serenity, we connect to WebDriver from the browser-side of the WebContent connection for both Browser and headless-browser. On Lagom, we connect from within the WebContent process itself, signaled by a command line flag. This patch changes Lagom browsers to connect to WebDriver the same way that Serenity browsers do. This will ensure we can do other initializers in the same order across all platforms and browsers.
2023-03-16 08:50:22 -04:00
if (on_webdriver_connection)
on_webdriver_connection(*m_webdriver);
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
return {};
}
LibWeb: Rename Layout::InitialContainingBlock to Layout::Viewport The name "initial containing block" was wrong for this, as it doesn't correspond to the HTML element, and that's specifically what it's supposed to do! :^)
2023-02-25 11:04:29 +01:00
Web::Layout::Viewport* PageHost::layout_root()
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 17:31:42 +02:00
{
LibWeb: Rename BrowsingContext::document() => active_document() This better matches the spec nomenclature. Note that we don't yet *retrieve* the active document according to spec.
2021-09-09 13:14:32 +02:00
auto* document = page().top_level_browsing_context().active_document();
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 17:31:42 +02:00
if (!document)
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
return nullptr;
return document->layout_node();
}
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 17:31:42 +02:00
LibWeb: Fill PageHost root with document background color This makes Acid3 have a background color again. Regressed with f2f14ad9bd9c18a1a1ab517343c706b43737761e.
2023-05-06 07:26:19 +02:00
Gfx::Color PageHost::background_color() const
{
auto document = page().top_level_browsing_context().active_document();
if (!document)
return Gfx::Color::Transparent;
return document->background_color();
}
LibWeb+WebContent+headless-browser: Make Page aware of the display scale For now, we just report it as "1" everywhere. Replaced `screen_rect()` with `web_exposed_screen_area()` from the spec.
2022-11-25 17:07:19 +00:00
void PageHost::paint(Web::DevicePixelRect const& content_rect, Gfx::Bitmap& target)
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
{
LibWeb+WebContent+headless-browser: Make Page aware of the display scale For now, we just report it as "1" everywhere. Replaced `screen_rect()` with `web_exposed_screen_area()` from the spec.
2022-11-25 17:07:19 +00:00
Gfx::IntRect bitmap_rect { {}, content_rect.size().to_type<int>() };
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
LibWeb: Make Document::paintable() return a ViewportPaintable
2023-08-19 09:29:04 +02:00
auto document = page().top_level_browsing_context().active_document();
if (document) {
LibWeb: Null-check document before doing layout in PageHost::paint()
2021-10-28 18:29:16 +02:00
document->update_layout();
LibWeb: Make Document::paintable() return a ViewportPaintable
2023-08-19 09:29:04 +02:00
}
LibWeb: Always update layout (if needed) before painting
2021-10-28 18:14:38 +02:00
LibWeb: Fill PageHost root with document background color This makes Acid3 have a background color again. Regressed with f2f14ad9bd9c18a1a1ab517343c706b43737761e.
2023-05-06 07:26:19 +02:00
auto background_color = this->background_color();
LibWeb: Introduce RecordingPainter to serialize painting commands This modification introduces a new layer to the painting process. The stacking context traversal no longer immediately calls the Gfx::Painter methods. Instead, it writes serialized painting commands into newly introduced RecordingPainter. Created list of commands is executed later to produce resulting bitmap. Producing painting command list will make it easier to add new optimizations: - It's simpler to check if the painting result is not visible in the viewport at the command level rather than during stacking context traversal. - Run painting in a separate thread. The painting thread can process serialized painting commands, while the main thread can work on the next paintable tree and safely invalidate the previous one. - As we consider GPU-accelerated painting support, it would be easier to back each painting command rather than constructing an alternative for the entire Gfx::Painter API.
2023-10-15 04:27:48 +02:00
Web::Painting::RecordingPainter recording_painter;
Web::PaintContext context(recording_painter, palette(), device_pixels_per_css_pixel());
LibWeb: Fill PageHost root with document background color This makes Acid3 have a background color again. Regressed with f2f14ad9bd9c18a1a1ab517343c706b43737761e.
2023-05-06 07:26:19 +02:00
if (background_color.alpha() < 255)
LibWeb: Remove ClearRect command in RecordingPainter There is only one usage of ClearRect command and it could be replaced with FillRect to make set of commands in RecordingPainter smaller.
2023-10-21 16:46:59 +02:00
recording_painter.fill_rect(bitmap_rect, Web::CSS::SystemColor::canvas());
LibWeb: Introduce RecordingPainter to serialize painting commands This modification introduces a new layer to the painting process. The stacking context traversal no longer immediately calls the Gfx::Painter methods. Instead, it writes serialized painting commands into newly introduced RecordingPainter. Created list of commands is executed later to produce resulting bitmap. Producing painting command list will make it easier to add new optimizations: - It's simpler to check if the painting result is not visible in the viewport at the command level rather than during stacking context traversal. - Run painting in a separate thread. The painting thread can process serialized painting commands, while the main thread can work on the next paintable tree and safely invalidate the previous one. - As we consider GPU-accelerated painting support, it would be easier to back each painting command rather than constructing an alternative for the entire Gfx::Painter API.
2023-10-15 04:27:48 +02:00
recording_painter.fill_rect(bitmap_rect, background_color);
LibWeb+WebContent: Make document background and Viewport transparent This means iframes are transparent by default (as in firefox/chrome). Painting the outermost canvas background is moved to the PageHost.
2023-04-24 22:38:50 +02:00
LibWeb: Make Document::paintable() return a ViewportPaintable
2023-08-19 09:29:04 +02:00
if (!document->paintable())
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 17:31:42 +02:00
return;
Browser+LibWeb+WebContent: Make the "Debug" menu work in multi-process This patch adds an IPC call for debugging requests. It's stringly typed and very simple, and allows us to easily implement all the features in the Browser's Debug menu.
2021-01-31 09:06:25 +01:00
context.set_should_show_line_box_borders(m_should_show_line_box_borders);
LibWeb: Split PaintContext::viewport_rect() into device/css variants For now, everyone uses `device_viewport_rect()`, until I convert them.
2022-10-27 14:37:05 +01:00
context.set_device_viewport_rect(content_rect);
LibWeb: Plumb OOPWV focus state across the IPC boundary This makes focus outlines show up in OOPWV at last! :^)
2022-02-06 19:03:13 +01:00
context.set_has_focus(m_has_focus);
LibWeb: Make Document::paintable() return a ViewportPaintable
2023-08-19 09:29:04 +02:00
document->paintable()->paint_all_phases(context);
LibWeb: Introduce RecordingPainter to serialize painting commands This modification introduces a new layer to the painting process. The stacking context traversal no longer immediately calls the Gfx::Painter methods. Instead, it writes serialized painting commands into newly introduced RecordingPainter. Created list of commands is executed later to produce resulting bitmap. Producing painting command list will make it easier to add new optimizations: - It's simpler to check if the painting result is not visible in the viewport at the command level rather than during stacking context traversal. - Run painting in a separate thread. The painting thread can process serialized painting commands, while the main thread can work on the next paintable tree and safely invalidate the previous one. - As we consider GPU-accelerated painting support, it would be easier to back each painting command rather than constructing an alternative for the entire Gfx::Painter API.
2023-10-15 04:27:48 +02:00
Ladybird+WebContent: Add option to use GPU painter Adds `--enable-gpu-painting` param to enable painting command executor that uses LibAccelGfx.
2023-10-27 17:28:18 +02:00
if (s_use_gpu_painter) {
WebContent: Use the accelerated_graphics CMake helper Instead of relying on AK_OS_LINUX, actually use the more accurate HAS_ACCELERATED_GRAPHICS define to figure out if we should try to use the generic LibAccelGfx GPU painter.
2023-10-31 13:47:22 -06:00
#ifdef HAS_ACCELERATED_GRAPHICS
LibAccelGfx+LibWeb: Add support for stacking context opacity For each stacking context with an opacity less than 1, we create a separate framebuffer. We then blit the texture attached to this framebuffer with the specified opacity. To avoid the performance overhead of reading pixels from the texture into Gfx::Bitmap, a new method that allows for direct blitting from the texture is introduced, named blit_scaled_texture().
2023-11-23 15:28:51 +01:00
Web::Painting::PaintingCommandExecutorGPU painting_command_executor(target);
Ladybird+WebContent: Add option to use GPU painter Adds `--enable-gpu-painting` param to enable painting command executor that uses LibAccelGfx.
2023-10-27 17:28:18 +02:00
recording_painter.execute(painting_command_executor);
#endif
} else {
Web::Painting::PaintingCommandExecutorCPU painting_command_executor(target);
recording_painter.execute(painting_command_executor);
}
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 17:31:42 +02:00
}
LibWeb+WebContent: Convert BrowsingContext to new pixel units This fixes a few glitches. We no longer give the page double the width it should have, and we mark the correct area of the page as needing repainting.
2022-11-03 12:49:54 +00:00
void PageHost::set_viewport_rect(Web::DevicePixelRect const& rect)
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 17:31:42 +02:00
{
LibWeb: Change viewport ownership from `BrowsingContext` to `Navigable`
2023-08-22 16:00:42 +02:00
page().top_level_traversable()->set_viewport_rect(page().device_to_css_rect(rect));
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 17:31:42 +02:00
}
LibWeb+WebContent+headless-browser: Use CSSPixels for PageClient events ...and also for hit testing, which is involved in most of them. Much of this is temporary conversions and other awkwardness, which should resolve itself as the rest of LibWeb is converted to these new types. Hopefully. :thousandyakstare:
2022-11-02 17:35:53 +00:00
void PageHost::page_did_invalidate(Web::CSSPixelRect const& content_rect)
WebContent: Allow the WebContent process to trigger repaints After layout, we may want to repaint the page, so we now listen for the PageClient::page_did_invalidate() notification and use it to drive a client-side repaint. Note that an invalidation request from LibWeb makes a full roundtrip to the WebContent client and back since the client drives painting.
2020-06-17 18:00:18 +02:00
{
LibWeb+WebContent+headless-browser: Use CSSPixels for PageClient events ...and also for hit testing, which is involved in most of them. Much of this is temporary conversions and other awkwardness, which should resolve itself as the rest of LibWeb is converted to these new types. Hopefully. :thousandyakstare:
2022-11-02 17:35:53 +00:00
m_invalidation_rect = m_invalidation_rect.united(page().enclosing_device_rect(content_rect));
WebContent: Coalesce paint invalidations to avoid spamming client Some content cause a lot of paint invalidations (e.g someone drawing to a <canvas> repeatedly) and we don't need to spam the client about this. Instead, accumulate a dirty rect, and send it once per event loop step.
2021-09-28 22:53:59 +02:00
if (!m_invalidation_coalescing_timer->is_active())
m_invalidation_coalescing_timer->start();
WebContent: Allow the WebContent process to trigger repaints After layout, we may want to repaint the page, so we now listen for the PageClient::page_did_invalidate() notification and use it to drive a client-side repaint. Note that an invalidation request from LibWeb makes a full roundtrip to the WebContent client and back since the client drives painting.
2020-06-17 18:00:18 +02:00
}
WebContent: Notify client when web content selection changes The WebContentView widgets reacts to this by requesting a repaint.
2020-07-04 20:57:57 +02:00
void PageHost::page_did_change_selection()
{
Userland: Update IPC calls to use proxies This updates all existing code to use the auto-generated client methods instead of post_message/send_sync.
2021-05-03 13:33:59 +02:00
m_client.async_did_change_selection();
WebContent: Notify client when web content selection changes The WebContentView widgets reacts to this by requesting a repaint.
2020-07-04 20:57:57 +02:00
}
LibWeb: Support setting the cursor in OutOfProcessWebView
2021-02-27 21:12:12 +00:00
void PageHost::page_did_request_cursor_change(Gfx::StandardCursor cursor)
{
Userland: Update IPC calls to use proxies This updates all existing code to use the auto-generated client methods instead of post_message/send_sync.
2021-05-03 13:33:59 +02:00
m_client.async_did_request_cursor_change((u32)cursor);
LibWeb: Support setting the cursor in OutOfProcessWebView
2021-02-27 21:12:12 +00:00
}
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
void PageHost::page_did_layout()
{
auto* layout_root = this->layout_root();
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(layout_root);
LibWeb: Bring measuring of scrollable overflow closer to spec Importantly, we now only consider overflow from descendants with explicltly visible overflow, and only from descendants that have the measured box as their containing block. Also, we now measure scrollable overflow for all boxes, not just scroll containers. This will allow us to fix a long-standing paint problem in the next commit.
2023-07-12 18:55:23 +02:00
if (layout_root->paintable_box()->has_scrollable_overflow())
LibWeb/Layout: Rename BlockContainer::paint{_box => able_with_lines}() It returns a PaintableBox (a PaintableWithLines, to be specific), not a 'PaintBox'. paintable_box() without the cast is already available through BlockContainer's Box base class, we don't need to shadow it.
2023-04-20 16:01:38 +01:00
m_content_size = page().enclosing_device_rect(layout_root->paintable_box()->scrollable_overflow_rect().value()).size();
LibWeb: Introduce simple scrollable overflow, size ICB to viewport Per spec, the initial containing block (ICB) should have the size of the viewport. We have only done this for the width until now, since we had no way to express scrollable overflow. This patch adds Layout::Box::m_overflow_data, an optional struct that can hold on to information about a box's overflow. Then we have BFC set the ICB up with some scrollable overflow instead of sizing it to fit its content vertically. This fixes a number of broken layouts where correctness depends on having the appropriate ICB height.
2021-10-14 22:23:20 +02:00
else
LibWeb/Layout: Rename BlockContainer::paint{_box => able_with_lines}() It returns a PaintableBox (a PaintableWithLines, to be specific), not a 'PaintBox'. paintable_box() without the cast is already available through BlockContainer's Box base class, we don't need to shadow it.
2023-04-20 16:01:38 +01:00
m_content_size = page().enclosing_device_rect(layout_root->paintable_box()->absolute_rect()).size();
LibWeb+WebContent+headless-browser: Make Page aware of the display scale For now, we just report it as "1" everywhere. Replaced `screen_rect()` with `web_exposed_screen_area()` from the spec.
2022-11-25 17:07:19 +00:00
m_client.async_did_layout(m_content_size.to_type<int>());
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
}
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
void PageHost::page_did_change_title(DeprecatedString const& title)
WebContent: Plumb title changes over to the WebContentView WebContentView now fires its on_title_change hook, like Web::PageView. We use this in the WebView test app to update the window title. :^)
2020-07-04 23:40:17 +02:00
{
Userland: Update IPC calls to use proxies This updates all existing code to use the auto-generated client methods instead of post_message/send_sync.
2021-05-03 13:33:59 +02:00
m_client.async_did_change_title(title);
WebContent: Plumb title changes over to the WebContentView WebContentView now fires its on_title_change hook, like Web::PageView. We use this in the WebView test app to update the window title. :^)
2020-07-04 23:40:17 +02:00
}
LibWeb+WebContent: Virtualize methods needed for WebDriver in PageClient WebDriver currently uses the WebContent::ConnectionFromClient IPC class directly for these features. To support headless-browser, WebDriver will instead need to rely on PageClient to provide these.
2022-11-21 16:10:57 -05:00
void PageHost::page_did_request_navigate_back()
{
m_client.async_did_request_navigate_back();
}
void PageHost::page_did_request_navigate_forward()
{
m_client.async_did_request_navigate_forward();
}
void PageHost::page_did_request_refresh()
{
m_client.async_did_request_refresh();
}
Meta+Userland: Pass Gfx::IntSize by value Just two ints like Gfx::IntPoint.
2022-12-06 21:35:32 +00:00
Gfx::IntSize PageHost::page_did_request_resize_window(Gfx::IntSize size)
LibWeb+WebContent: Virtualize methods needed for WebDriver in PageClient WebDriver currently uses the WebContent::ConnectionFromClient IPC class directly for these features. To support headless-browser, WebDriver will instead need to rely on PageClient to provide these.
2022-11-21 16:10:57 -05:00
{
return m_client.did_request_resize_window(size);
}
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
Gfx::IntPoint PageHost::page_did_request_reposition_window(Gfx::IntPoint position)
LibWeb+WebContent: Virtualize methods needed for WebDriver in PageClient WebDriver currently uses the WebContent::ConnectionFromClient IPC class directly for these features. To support headless-browser, WebDriver will instead need to rely on PageClient to provide these.
2022-11-21 16:10:57 -05:00
{
return m_client.did_request_reposition_window(position);
}
void PageHost::page_did_request_restore_window()
{
m_client.async_did_request_restore_window();
}
Gfx::IntRect PageHost::page_did_request_maximize_window()
{
return m_client.did_request_maximize_window();
}
Gfx::IntRect PageHost::page_did_request_minimize_window()
{
return m_client.did_request_minimize_window();
}
Gfx::IntRect PageHost::page_did_request_fullscreen_window()
{
return m_client.did_request_fullscreen_window();
}
LibWeb+WebContent: Modify did_request_scroll() IPC to take x&y deltas This is in preparation for implementing JS scrolling functions, which specify both x and y scrolling deltas. The visible behavior has not changed. Also, moved the "mouse wheel delta * 20" calculation to the `EventHandler` since the JS calls will want to work directly in pixels.
2021-09-08 11:22:44 +01:00
void PageHost::page_did_request_scroll(i32 x_delta, i32 y_delta)
LibWeb: Handle scrolling an OutOfProcessWebView When a mousewheel scroll event isn't handled by the web content itself (e.g. an overflowed box or similar), the event needs to get passed back up to the OutOfProcessWebView.
2021-03-02 08:39:07 +11:00
{
LibWeb+WebContent: Modify did_request_scroll() IPC to take x&y deltas This is in preparation for implementing JS scrolling functions, which specify both x and y scrolling deltas. The visible behavior has not changed. Also, moved the "mouse wheel delta * 20" calculation to the `EventHandler` since the JS calls will want to work directly in pixels.
2021-09-08 11:22:44 +01:00
m_client.async_did_request_scroll(x_delta, y_delta);
LibWeb: Handle scrolling an OutOfProcessWebView When a mousewheel scroll event isn't handled by the web content itself (e.g. an overflowed box or similar), the event needs to get passed back up to the OutOfProcessWebView.
2021-03-02 08:39:07 +11:00
}
LibWeb+WebContent+headless-browser: Use CSSPixels for PageClient events ...and also for hit testing, which is involved in most of them. Much of this is temporary conversions and other awkwardness, which should resolve itself as the rest of LibWeb is converted to these new types. Hopefully. :thousandyakstare:
2022-11-02 17:35:53 +00:00
void PageHost::page_did_request_scroll_to(Web::CSSPixelPoint scroll_position)
LibWeb+WebContent: Add WebContentClient::did_request_scroll_to() call This call sets the absolute scroll position for the window.
2021-09-08 11:44:36 +01:00
{
LibWeb+LibWebView+Ladybird: Scale scroll-to CSS positions in PageHost The `page_did_request_scroll_to` API takes a CSS position, and thus callers should not scale to device pixels before invoking it. Instead, align this API with (most) other PageHost APIs which scale to device pixels before sending the corresponding IPC message. In the AppKit chrome, convert the provided device pixel position to a widget position.
2023-11-24 12:17:16 -05:00
auto device_scroll_position = page().css_to_device_point(scroll_position);
m_client.async_did_request_scroll_to(device_scroll_position.to_type<int>());
LibWeb+WebContent: Add WebContentClient::did_request_scroll_to() call This call sets the absolute scroll position for the window.
2021-09-08 11:44:36 +01:00
}
LibWeb+WebContent+headless-browser: Use CSSPixels for PageClient events ...and also for hit testing, which is involved in most of them. Much of this is temporary conversions and other awkwardness, which should resolve itself as the rest of LibWeb is converted to these new types. Hopefully. :thousandyakstare:
2022-11-02 17:35:53 +00:00
void PageHost::page_did_request_scroll_into_view(Web::CSSPixelRect const& rect)
WebContent: Plumb scroll-into-view requests from server to client The WebContentView widget will now be able to react to scroll-into-view requests from the WebContent process.
2020-07-05 15:43:43 +02:00
{
LibWeb+WebContent+headless-browser: Use CSSPixels for PageClient events ...and also for hit testing, which is involved in most of them. Much of this is temporary conversions and other awkwardness, which should resolve itself as the rest of LibWeb is converted to these new types. Hopefully. :thousandyakstare:
2022-11-02 17:35:53 +00:00
auto device_pixel_rect = page().enclosing_device_rect(rect);
m_client.async_did_request_scroll_into_view({ device_pixel_rect.x().value(),
device_pixel_rect.y().value(),
device_pixel_rect.width().value(),
device_pixel_rect.height().value() });
WebContent: Plumb scroll-into-view requests from server to client The WebContentView widget will now be able to react to scroll-into-view requests from the WebContent process.
2020-07-05 15:43:43 +02:00
}
LibWeb+WebContent+headless-browser: Use CSSPixels for PageClient events ...and also for hit testing, which is involved in most of them. Much of this is temporary conversions and other awkwardness, which should resolve itself as the rest of LibWeb is converted to these new types. Hopefully. :thousandyakstare:
2022-11-02 17:35:53 +00:00
void PageHost::page_did_enter_tooltip_area(Web::CSSPixelPoint content_position, DeprecatedString const& title)
LibWeb+WebContent: Support displaying tooltips in OOPWV
2021-03-30 12:10:06 -04:00
{
LibWeb+WebContent: Forbid access to underlying type of CSSPixels Although DistinctNumeric, which is supposed to abstract the underlying type, was used to represent CSSPixels, we have a whole bunch of places in the layout code that assume CSSPixels::value() returns a floating-point type. This assumption makes it difficult to replace the underlying type in CSSPixels with a non-floating type. To make it easier to transition CSSPixels to fixed-point math, one step we can take is to prevent access to the underlying type using value() and instead use explicit conversions with the to_float(), to_double(), and to_int() methods.
2023-06-12 21:37:35 +03:00
m_client.async_did_enter_tooltip_area({ content_position.x().to_int(), content_position.y().to_int() }, title);
LibWeb+WebContent: Support displaying tooltips in OOPWV
2021-03-30 12:10:06 -04:00
}
void PageHost::page_did_leave_tooltip_area()
{
Userland: Update IPC calls to use proxies This updates all existing code to use the auto-generated client methods instead of post_message/send_sync.
2021-05-03 13:33:59 +02:00
m_client.async_did_leave_tooltip_area();
LibWeb+WebContent: Support displaying tooltips in OOPWV
2021-03-30 12:10:06 -04:00
}
WebContent: Plumb hovered links from WebContent process over to widget Also add a little GUI::StatusBar to the demo app so we can see the hovered link URL's live. :^)
2020-07-05 16:59:20 +02:00
void PageHost::page_did_hover_link(const URL& url)
{
Userland: Update IPC calls to use proxies This updates all existing code to use the auto-generated client methods instead of post_message/send_sync.
2021-05-03 13:33:59 +02:00
m_client.async_did_hover_link(url);
WebContent: Plumb hovered links from WebContent process over to widget Also add a little GUI::StatusBar to the demo app so we can see the hovered link URL's live. :^)
2020-07-05 16:59:20 +02:00
}
void PageHost::page_did_unhover_link()
{
Userland: Update IPC calls to use proxies This updates all existing code to use the auto-generated client methods instead of post_message/send_sync.
2021-05-03 13:33:59 +02:00
m_client.async_did_unhover_link();
WebContent: Plumb hovered links from WebContent process over to widget Also add a little GUI::StatusBar to the demo app so we can see the hovered link URL's live. :^)
2020-07-05 16:59:20 +02:00
}
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
void PageHost::page_did_click_link(const URL& url, DeprecatedString const& target, unsigned modifiers)
WebContent: Plumb link clicks to the WebContentView :^) You can now react to links being clicked via the on_link_click hook.
2020-07-06 20:01:46 +02:00
{
Userland: Update IPC calls to use proxies This updates all existing code to use the auto-generated client methods instead of post_message/send_sync.
2021-05-03 13:33:59 +02:00
m_client.async_did_click_link(url, target, modifiers);
WebContent: Plumb link clicks to the WebContentView :^) You can now react to links being clicked via the on_link_click hook.
2020-07-06 20:01:46 +02:00
}
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
void PageHost::page_did_middle_click_link(const URL& url, [[maybe_unused]] DeprecatedString const& target, [[maybe_unused]] unsigned modifiers)
WebContent: Plumb link clicks to the WebContentView :^) You can now react to links being clicked via the on_link_click hook.
2020-07-06 20:01:46 +02:00
{
Userland: Update IPC calls to use proxies This updates all existing code to use the auto-generated client methods instead of post_message/send_sync.
2021-05-03 13:33:59 +02:00
m_client.async_did_middle_click_link(url, target, modifiers);
WebContent: Plumb link clicks to the WebContentView :^) You can now react to links being clicked via the on_link_click hook.
2020-07-06 20:01:46 +02:00
}
LibWeb+WebContent: Label redirects with new FrameLoader::Type::Redirect Previously we labeled redirects as normal FrameLoader::Type::Navigation, now we introduce a new FrameLoader::Type::Redirect and label redirects with it. This will allow us to handle redirects in the browser differently (such as for overwritting the latest history entry when a redirect happens) :^)
2022-11-10 00:29:35 +01:00
void PageHost::page_did_start_loading(const URL& url, bool is_redirect)
LibWeb: Make the WebContentView::on_load_start hook actually work :^)
2020-07-06 21:58:16 +02:00
{
LibWeb+WebContent: Label redirects with new FrameLoader::Type::Redirect Previously we labeled redirects as normal FrameLoader::Type::Navigation, now we introduce a new FrameLoader::Type::Redirect and label redirects with it. This will allow us to handle redirects in the browser differently (such as for overwritting the latest history entry when a redirect happens) :^)
2022-11-10 00:29:35 +01:00
m_client.async_did_start_loading(url, is_redirect);
LibWeb: Make the WebContentView::on_load_start hook actually work :^)
2020-07-06 21:58:16 +02:00
}
LibWeb+WebContent: Set ConsoleClient for nested browsing contexts Before page_did_create_main_document() only initialized ConsoleClient for top-level browsing context which means that nested browsing context could not print into the console. With this change, ConsoleClient is initialized for documents created for nested browsing context too. One ConsoleClient is shared between all browsing contexts within the same page.
2023-09-07 12:11:37 +02:00
void PageHost::page_did_create_new_document(Web::DOM::Document& document)
LibWeb+WebContent: Add on_load_finish hook to web views This isn't entirely symmetrical with on_load_start as it will also fire on reloads and back/forward navigations. However, it's good enough for some basic use cases, and we can do more sophisticated notifications later on when we need them.
2020-12-08 21:44:42 +01:00
{
LibWeb+WebContent: Set ConsoleClient for nested browsing contexts Before page_did_create_main_document() only initialized ConsoleClient for top-level browsing context which means that nested browsing context could not print into the console. With this change, ConsoleClient is initialized for documents created for nested browsing context too. One ConsoleClient is shared between all browsing contexts within the same page.
2023-09-07 12:11:37 +02:00
m_client.initialize_js_console({}, document);
LibWeb+WebContent: Setup the js console client earlier This allows us to print messages in inline scripts. Also add an example of this in the welcome page to test this.
2022-09-21 17:12:00 +02:00
}
LibWeb+WebContent: Create `WebContentConsoleClient` for every document Fixes regression introduced in b4fe118dff6c1bd839f0443f9d822ae078895814 The `WebContentConsoleClient` needs to be created not just once, but for every new document. Although the JS Console window allows communication only with the active document associated with the top-level browsing context, we still need a console client for each iframe's document to ensure their console logs are printed. In the future, we might consider adding the ability to switch which document the JS Console window communicates with. Fixes https://github.com/SerenityOS/serenity/issues/21117
2023-09-17 16:11:16 +02:00
void PageHost::page_did_destroy_document(Web::DOM::Document& document)
{
m_client.destroy_js_console({}, document);
}
LibWeb+WebContent: Setup the js console client earlier This allows us to print messages in inline scripts. Also add an example of this in the welcome page to test this.
2022-09-21 17:12:00 +02:00
void PageHost::page_did_finish_loading(const URL& url)
{
Userland: Update IPC calls to use proxies This updates all existing code to use the auto-generated client methods instead of post_message/send_sync.
2021-05-03 13:33:59 +02:00
m_client.async_did_finish_loading(url);
LibWeb+WebContent: Add on_load_finish hook to web views This isn't entirely symmetrical with on_load_start as it will also fire on reloads and back/forward navigations. However, it's good enough for some basic use cases, and we can do more sophisticated notifications later on when we need them.
2020-12-08 21:44:42 +01:00
}
LibWeb+WebContent+headless-browser: Support async text tests Previously, we used `on_load_finish` to determine when the text test was completed. This method did not allow testing of async functions because there was no way to indicate that the runner should wait for the async call to end. This change introduces a function in the `internals` object that is intended to be called when the text test execution is completed. The text test runner will now ignore `on_load_finish` which means a test will timeout if this new function is never called. `test(f)` function in `include.js` has been modified to automatically terminate a test once `load` event is fired on `window`. new `asyncTest(f)` function has been introduces. `f` receives function that will terminate a test as a first argument. Every test is expected to call either `test()` or `asyncTest()` to complete. If not, it will remain hanging until a timeout occurs.
2023-09-14 19:17:32 +02:00
void PageHost::page_did_finish_text_test()
{
m_client.async_did_finish_text_test();
}
LibWeb+WebContent+headless-browser: Use CSSPixels for PageClient events ...and also for hit testing, which is involved in most of them. Much of this is temporary conversions and other awkwardness, which should resolve itself as the rest of LibWeb is converted to these new types. Hopefully. :thousandyakstare:
2022-11-02 17:35:53 +00:00
void PageHost::page_did_request_context_menu(Web::CSSPixelPoint content_position)
LibWeb: Make context menus work in WebContentView As usual, this was just a matter of plumbing the PageClient calls from the WebContent side over to the WebContentView side. :^)
2020-07-07 12:24:29 +02:00
{
LibWeb+WebContent+headless-browser: Use CSSPixels for PageClient events ...and also for hit testing, which is involved in most of them. Much of this is temporary conversions and other awkwardness, which should resolve itself as the rest of LibWeb is converted to these new types. Hopefully. :thousandyakstare:
2022-11-02 17:35:53 +00:00
m_client.async_did_request_context_menu(page().css_to_device_point(content_position).to_type<int>());
LibWeb: Make context menus work in WebContentView As usual, this was just a matter of plumbing the PageClient calls from the WebContent side over to the WebContentView side. :^)
2020-07-07 12:24:29 +02:00
}
LibWeb+WebContent+headless-browser: Use CSSPixels for PageClient events ...and also for hit testing, which is involved in most of them. Much of this is temporary conversions and other awkwardness, which should resolve itself as the rest of LibWeb is converted to these new types. Hopefully. :thousandyakstare:
2022-11-02 17:35:53 +00:00
void PageHost::page_did_request_link_context_menu(Web::CSSPixelPoint content_position, URL const& url, DeprecatedString const& target, unsigned modifiers)
LibWeb: Make context menus work in WebContentView As usual, this was just a matter of plumbing the PageClient calls from the WebContent side over to the WebContentView side. :^)
2020-07-07 12:24:29 +02:00
{
LibWeb+WebContent+headless-browser: Use CSSPixels for PageClient events ...and also for hit testing, which is involved in most of them. Much of this is temporary conversions and other awkwardness, which should resolve itself as the rest of LibWeb is converted to these new types. Hopefully. :thousandyakstare:
2022-11-02 17:35:53 +00:00
m_client.async_did_request_link_context_menu(page().css_to_device_point(content_position).to_type<int>(), url, target, modifiers);
LibWeb: Make context menus work in WebContentView As usual, this was just a matter of plumbing the PageClient calls from the WebContent side over to the WebContentView side. :^)
2020-07-07 12:24:29 +02:00
}
WebContent: Group context menu request definitions together Having all 4 of these methods together makes it more immediately obvious that the 2 moved here are not correct (we are not converting the CSS pixel point to a device pixel point).
2023-08-17 17:59:18 -04:00
void PageHost::page_did_request_image_context_menu(Web::CSSPixelPoint content_position, URL const& url, DeprecatedString const& target, unsigned modifiers, Gfx::Bitmap const* bitmap_pointer)
{
auto bitmap = bitmap_pointer ? bitmap_pointer->to_shareable_bitmap() : Gfx::ShareableBitmap();
WebContent: Convert image/media context menu positions to device pixels On Serenity and on my Linux machine, we have a 1:1 CSS-to-device pixel ratio. On macOS, we have a 2:1 ratio. This did not affect the Qt chrome, because we are ignoring this position and placing the context menu at the globally-accessible mouse position. The AppKit chrome will be using this position, though. This might be what caused the issue worked around by commit 8177ecb.
2023-08-17 18:01:05 -04:00
m_client.async_did_request_image_context_menu(page().css_to_device_point(content_position).to_type<int>(), url, target, modifiers, bitmap);
WebContent: Group context menu request definitions together Having all 4 of these methods together makes it more immediately obvious that the 2 moved here are not correct (we are not converting the CSS pixel point to a device pixel point).
2023-08-17 17:59:18 -04:00
}
void PageHost::page_did_request_media_context_menu(Web::CSSPixelPoint content_position, DeprecatedString const& target, unsigned modifiers, Web::Page::MediaContextMenu menu)
{
WebContent: Convert image/media context menu positions to device pixels On Serenity and on my Linux machine, we have a 1:1 CSS-to-device pixel ratio. On macOS, we have a 2:1 ratio. This did not affect the Qt chrome, because we are ignoring this position and placing the context menu at the globally-accessible mouse position. The AppKit chrome will be using this position, though. This might be what caused the issue worked around by commit 8177ecb.
2023-08-17 18:01:05 -04:00
m_client.async_did_request_media_context_menu(page().css_to_device_point(content_position).to_type<int>(), target, modifiers, move(menu));
WebContent: Group context menu request definitions together Having all 4 of these methods together makes it more immediately obvious that the 2 moved here are not correct (we are not converting the CSS pixel point to a device pixel point).
2023-08-17 17:59:18 -04:00
}
LibWeb+Ladybird+Userland: Port window.[alert,confirm,prompt] to String LibGUI and WebDriver (read: JSON) API boundaries use DeprecatedString, so that is as far as these changes can reach. The one change which isn't just a DeprecatedString to String replacement is handling the "null" prompt response. We previously checked for the null DeprecatedString, whereas we now represent this as an empty Optional<String>.
2023-03-13 17:30:51 -04:00
void PageHost::page_did_request_alert(String const& message)
LibWebView+WebContent: Wait for dialog responses without blocking IPC Currently, the WebContent process is completely blocked while waiting for a response to a dialog request. This patch allows the IPC event loop to continue executing while only blocking the HTML event loop. This will allow other processes like WebDriver to continue to operate on the WebContent process while a dialog is open.
2022-11-15 15:49:36 -05:00
{
m_client.async_did_request_alert(message);
}
void PageHost::alert_closed()
{
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 15:18:42 -05:00
page().alert_closed();
LibWeb: Support window.alert() in multi-process context Alerts are now delegated to the embedding GUI process.
2020-09-12 11:56:13 +02:00
}
LibWeb+Ladybird+Userland: Port window.[alert,confirm,prompt] to String LibGUI and WebDriver (read: JSON) API boundaries use DeprecatedString, so that is as far as these changes can reach. The one change which isn't just a DeprecatedString to String replacement is handling the "null" prompt response. We previously checked for the null DeprecatedString, whereas we now represent this as an empty Optional<String>.
2023-03-13 17:30:51 -04:00
void PageHost::page_did_request_confirm(String const& message)
LibWeb+WebContent: Support window.confirm() in OOPWV
2021-02-10 08:48:28 +01:00
{
LibWebView+WebContent: Wait for dialog responses without blocking IPC Currently, the WebContent process is completely blocked while waiting for a response to a dialog request. This patch allows the IPC event loop to continue executing while only blocking the HTML event loop. This will allow other processes like WebDriver to continue to operate on the WebContent process while a dialog is open.
2022-11-15 15:49:36 -05:00
m_client.async_did_request_confirm(message);
}
void PageHost::confirm_closed(bool accepted)
{
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 15:18:42 -05:00
page().confirm_closed(accepted);
LibWeb+WebContent: Support window.confirm() in OOPWV
2021-02-10 08:48:28 +01:00
}
LibWeb+Ladybird+Userland: Port window.[alert,confirm,prompt] to String LibGUI and WebDriver (read: JSON) API boundaries use DeprecatedString, so that is as far as these changes can reach. The one change which isn't just a DeprecatedString to String replacement is handling the "null" prompt response. We previously checked for the null DeprecatedString, whereas we now represent this as an empty Optional<String>.
2023-03-13 17:30:51 -04:00
void PageHost::page_did_request_prompt(String const& message, String const& default_)
LibWeb: Implement Window.prompt()
2021-02-20 12:05:18 +01:00
{
LibWebView+WebContent: Wait for dialog responses without blocking IPC Currently, the WebContent process is completely blocked while waiting for a response to a dialog request. This patch allows the IPC event loop to continue executing while only blocking the HTML event loop. This will allow other processes like WebDriver to continue to operate on the WebContent process while a dialog is open.
2022-11-15 15:49:36 -05:00
m_client.async_did_request_prompt(message, default_);
}
LibWeb+Ladybird+Userland: Port window.[alert,confirm,prompt] to String LibGUI and WebDriver (read: JSON) API boundaries use DeprecatedString, so that is as far as these changes can reach. The one change which isn't just a DeprecatedString to String replacement is handling the "null" prompt response. We previously checked for the null DeprecatedString, whereas we now represent this as an empty Optional<String>.
2023-03-13 17:30:51 -04:00
void PageHost::page_did_request_set_prompt_text(String const& text)
LibWeb+WebContent: Virtualize methods needed for WebDriver in PageClient WebDriver currently uses the WebContent::ConnectionFromClient IPC class directly for these features. To support headless-browser, WebDriver will instead need to rely on PageClient to provide these.
2022-11-21 16:10:57 -05:00
{
m_client.async_did_request_set_prompt_text(text);
}
LibWeb+Ladybird+Userland: Port window.[alert,confirm,prompt] to String LibGUI and WebDriver (read: JSON) API boundaries use DeprecatedString, so that is as far as these changes can reach. The one change which isn't just a DeprecatedString to String replacement is handling the "null" prompt response. We previously checked for the null DeprecatedString, whereas we now represent this as an empty Optional<String>.
2023-03-13 17:30:51 -04:00
void PageHost::prompt_closed(Optional<String> response)
LibWebView+WebContent: Wait for dialog responses without blocking IPC Currently, the WebContent process is completely blocked while waiting for a response to a dialog request. This patch allows the IPC event loop to continue executing while only blocking the HTML event loop. This will allow other processes like WebDriver to continue to operate on the WebContent process while a dialog is open.
2022-11-15 15:49:36 -05:00
{
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 15:18:42 -05:00
page().prompt_closed(move(response));
LibWeb: Implement Window.prompt()
2021-02-20 12:05:18 +01:00
}
LibWeb+LibWebView+WebContent: Add support for <input type="color"> This commit introduces 3 things: - Support for the color type in HTMLInputElement itself - A mechanism for handling non event loop blocking dialogs in Page - The associated plumbing up to ViewImplementation Frontends may add support for the color picker with the ViewImplementation.on_request_color_picker function
2023-09-04 11:32:40 +02:00
void PageHost::color_picker_closed(Optional<Color> picked_color)
{
page().color_picker_closed(picked_color);
}
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 10:51:38 -04:00
Web::WebIDL::ExceptionOr<void> PageHost::toggle_media_play_state()
LibWeb+WebContent: Add APIs to control video playback state This allows for the browser process to control the play/pause state, whether we paint user agent controls on the video, and whether the video loops when it finishes playing.
2023-05-15 11:17:58 -04:00
{
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 10:51:38 -04:00
return page().toggle_media_play_state();
LibWeb+WebContent: Add APIs to control video playback state This allows for the browser process to control the play/pause state, whether we paint user agent controls on the video, and whether the video loops when it finishes playing.
2023-05-15 11:17:58 -04:00
}
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 11:29:54 -04:00
void PageHost::toggle_media_mute_state()
{
page().toggle_media_mute_state();
}
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 10:51:38 -04:00
Web::WebIDL::ExceptionOr<void> PageHost::toggle_media_loop_state()
LibWeb+WebContent: Add APIs to control video playback state This allows for the browser process to control the play/pause state, whether we paint user agent controls on the video, and whether the video loops when it finishes playing.
2023-05-15 11:17:58 -04:00
{
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 10:51:38 -04:00
return page().toggle_media_loop_state();
LibWeb+WebContent: Add APIs to control video playback state This allows for the browser process to control the play/pause state, whether we paint user agent controls on the video, and whether the video loops when it finishes playing.
2023-05-15 11:17:58 -04:00
}
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 10:51:38 -04:00
Web::WebIDL::ExceptionOr<void> PageHost::toggle_media_controls_state()
LibWeb+WebContent: Add APIs to control video playback state This allows for the browser process to control the play/pause state, whether we paint user agent controls on the video, and whether the video loops when it finishes playing.
2023-05-15 11:17:58 -04:00
{
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 10:51:38 -04:00
return page().toggle_media_controls_state();
LibWeb+WebContent: Add APIs to control video playback state This allows for the browser process to control the play/pause state, whether we paint user agent controls on the video, and whether the video loops when it finishes playing.
2023-05-15 11:17:58 -04:00
}
WebContent+LibWebView: Add support for user style sheets
2023-08-21 15:50:31 +01:00
void PageHost::set_user_style(String source)
{
page().set_user_style(source);
}
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 15:18:42 -05:00
void PageHost::page_did_request_accept_dialog()
LibWebView+WebContent: Begin handling open user dialogs for WebDriver The way in which dialogs should be handled is configurable by the driver capabilities object, which we don't support yet. So this implements just the default mode to dismiss the dialog and return an error if there is one open. In the OOPWV, this means we need to refer to the dialog after it has been open, so we now hold a pointer to whatever dialog is open.
2022-11-16 06:58:14 -05:00
{
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 15:18:42 -05:00
m_client.async_did_request_accept_dialog();
LibWebView+WebContent: Begin handling open user dialogs for WebDriver The way in which dialogs should be handled is configurable by the driver capabilities object, which we don't support yet. So this implements just the default mode to dismiss the dialog and return an error if there is one open. In the OOPWV, this means we need to refer to the dialog after it has been open, so we now hold a pointer to whatever dialog is open.
2022-11-16 06:58:14 -05:00
}
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 15:18:42 -05:00
void PageHost::page_did_request_dismiss_dialog()
LibWeb+WebContent+WebDriver: Implement Accept Alert
2022-11-16 07:24:22 -05:00
{
LibWeb+WebContent: Move pending dialog handling from PageHost to Page Currently, all handling of pending dialogs occurs in PageHost. In order to re-use this functionality to run WebDriver in a headless move, move it to Page.
2022-11-21 15:18:42 -05:00
m_client.async_did_request_dismiss_dialog();
LibWeb+WebContent+WebDriver: Implement Accept Alert
2022-11-16 07:24:22 -05:00
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void PageHost::page_did_change_favicon(Gfx::Bitmap const& favicon)
LibWeb+WebContent: Support displaying favicons in OOPWV In single process mode, the browser will display a page's favicon in both the location bar and tab. This adds the same support for multi- process mode.
2021-03-26 10:41:25 -04:00
{
Userland: Update IPC calls to use proxies This updates all existing code to use the auto-generated client methods instead of post_message/send_sync.
2021-05-03 13:33:59 +02:00
m_client.async_did_change_favicon(favicon.to_shareable_bitmap());
LibWeb+WebContent: Support displaying favicons in OOPWV In single process mode, the browser will display a page's favicon in both the location bar and tab. This adds the same support for multi- process mode.
2021-03-26 10:41:25 -04:00
}
LibWeb+WebContent: Virtualize methods needed for WebDriver in PageClient WebDriver currently uses the WebContent::ConnectionFromClient IPC class directly for these features. To support headless-browser, WebDriver will instead need to rely on PageClient to provide these.
2022-11-21 16:10:57 -05:00
Vector<Web::Cookie::Cookie> PageHost::page_did_request_all_cookies(URL const& url)
{
return m_client.did_request_all_cookies(url);
}
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
Optional<Web::Cookie::Cookie> PageHost::page_did_request_named_cookie(URL const& url, DeprecatedString const& name)
LibWeb+WebContent: Virtualize methods needed for WebDriver in PageClient WebDriver currently uses the WebContent::ConnectionFromClient IPC class directly for these features. To support headless-browser, WebDriver will instead need to rely on PageClient to provide these.
2022-11-21 16:10:57 -05:00
{
return m_client.did_request_named_cookie(url, name);
}
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
DeprecatedString PageHost::page_did_request_cookie(const URL& url, Web::Cookie::Source source)
LibWeb+WebContent: Hook document.cookie to the backend cookie storage
2021-04-11 10:54:11 -04:00
{
WebContent: Exit peacefully when client dies during synchronous IPC If we're waiting for the client (typically Browser) to respond to a synchronous IPC message from our side (e.g window.alert()) and the client disconnects instead, just exit peacefully. Ultimately a WebContent process lives to serve its client. When the client dies, there is no need for WebContent anymore.
2022-02-16 11:53:21 +01:00
auto response = m_client.send_sync_but_allow_failure<Messages::WebContentClient::DidRequestCookie>(move(url), static_cast<u8>(source));
if (!response) {
dbgln("WebContent client disconnected during DidRequestCookie. Exiting peacefully.");
exit(0);
}
return response->take_cookie();
LibWeb+WebContent: Hook document.cookie to the backend cookie storage
2021-04-11 10:54:11 -04:00
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void PageHost::page_did_set_cookie(const URL& url, Web::Cookie::ParsedCookie const& cookie, Web::Cookie::Source source)
LibWeb+WebContent: Hook document.cookie to the backend cookie storage
2021-04-11 10:54:11 -04:00
{
Userland: Update IPC calls to use proxies This updates all existing code to use the auto-generated client methods instead of post_message/send_sync.
2021-05-03 13:33:59 +02:00
m_client.async_did_set_cookie(url, cookie, static_cast<u8>(source));
LibWeb+WebContent: Hook document.cookie to the backend cookie storage
2021-04-11 10:54:11 -04:00
}
Browser+LibWebView+WebContent: Do not domain match on cookie updates Updating cookies through these hooks happens in one of two manners: 1. Through the Browser's storage inspector. 2. Through WebDriver's delete-cookies operation. In (1), we should not restrict ourselves to being able to delete cookies for the current page. For example, it's handy to open the inspector from the welcome page and be able to delete cookies for any domain. In (2), we already are only interacting with cookies that have been matched against the document URL.
2022-11-28 11:24:04 -05:00
void PageHost::page_did_update_cookie(Web::Cookie::Cookie cookie)
LibWeb+WebContent: Virtualize methods needed for WebDriver in PageClient WebDriver currently uses the WebContent::ConnectionFromClient IPC class directly for these features. To support headless-browser, WebDriver will instead need to rely on PageClient to provide these.
2022-11-21 16:10:57 -05:00
{
Browser+LibWebView+WebContent: Do not domain match on cookie updates Updating cookies through these hooks happens in one of two manners: 1. Through the Browser's storage inspector. 2. Through WebDriver's delete-cookies operation. In (1), we should not restrict ourselves to being able to delete cookies for the current page. For example, it's handy to open the inspector from the welcome page and be able to delete cookies for any domain. In (2), we already are only interacting with cookies that have been matched against the document URL.
2022-11-28 11:24:04 -05:00
m_client.async_did_update_cookie(move(cookie));
LibWeb+WebContent: Virtualize methods needed for WebDriver in PageClient WebDriver currently uses the WebContent::ConnectionFromClient IPC class directly for these features. To support headless-browser, WebDriver will instead need to rely on PageClient to provide these.
2022-11-21 16:10:57 -05:00
}
Browser: Show currently loading host and remaining resource count
2022-02-20 17:03:39 -05:00
void PageHost::page_did_update_resource_count(i32 count_waiting)
{
m_client.async_did_update_resource_count(count_waiting);
}
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 18:39:20 -04:00
String PageHost::page_did_request_new_tab(Web::HTML::ActivateTab activate_tab)
LibWeb+LibWebView+WebContent+Ladybird: Add IPC call that opens new tab
2023-03-14 17:12:09 +03:00
{
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 18:39:20 -04:00
return m_client.did_request_new_tab(activate_tab);
LibWeb+LibWebView+WebContent+Ladybird: Add IPC call that opens new tab
2023-03-14 17:12:09 +03:00
}
WebContent+Everywhere: Add a WebContent IPC to activate a tab
2023-03-20 19:52:00 -04:00
void PageHost::page_did_request_activate_tab()
{
m_client.async_did_request_activate_tab();
}
LibWebView+WebContent: Propagate close from WebContent to LibWebView
2023-03-07 06:10:26 +03:00
void PageHost::page_did_close_browsing_context(Web::HTML::BrowsingContext const&)
{
m_client.async_did_close_browsing_context();
}
LibWeb+WebContent: Do not reference-count file request objects There is currently a memory leak with these file request objects due to the callback on_file_request_finish referencing itself in its capture list. This object does not need to be reference counted or allocated on the heap. It is only ever stored in a HashMap until a response is received from the browser, and it is not shared.
2023-01-30 16:35:47 -05:00
void PageHost::request_file(Web::FileRequest file_request)
Browser+LibWeb+WebContent: Allow Browser to load local files To achieve this goal: - The Browser unveils "/tmp/portal/filesystemaccess" - Pass the page through LoadRequest => ResourceLoader - ResourceLoader requests a file to the FileSystemAccessServer via IPC - OutOfProcessWebView handles it and sends a file descriptor back to the Page.
2022-02-26 17:50:31 +01:00
{
LibWeb+WebContent: Do not reference-count file request objects There is currently a memory leak with these file request objects due to the callback on_file_request_finish referencing itself in its capture list. This object does not need to be reference counted or allocated on the heap. It is only ever stored in a HashMap until a response is received from the browser, and it is not shared.
2023-01-30 16:35:47 -05:00
m_client.request_file(move(file_request));
Browser+LibWeb+WebContent: Allow Browser to load local files To achieve this goal: - The Browser unveils "/tmp/portal/filesystemaccess" - Pass the page through LoadRequest => ResourceLoader - ResourceLoader requests a file to the FileSystemAccessServer via IPC - OutOfProcessWebView handles it and sends a file descriptor back to the Page.
2022-02-26 17:50:31 +01:00
}
LibWeb+LibWebView+WebContent: Add support for <input type="color"> This commit introduces 3 things: - Support for the color type in HTMLInputElement itself - A mechanism for handling non event loop blocking dialogs in Page - The associated plumbing up to ViewImplementation Frontends may add support for the color picker with the ViewImplementation.on_request_color_picker function
2023-09-04 11:32:40 +02:00
void PageHost::page_did_request_color_picker(Color current_color)
{
m_client.async_did_request_color_picker(current_color);
}
LibWeb+LibWebView+WebContent: Add support for meta theme-color
2023-09-19 01:51:48 +02:00
void PageHost::page_did_change_theme_color(Gfx::Color color)
{
m_client.async_did_change_theme_color(color);
}
LibWebView+WebContent: Add an IPC hook to insert data into the clipboard
2023-11-10 13:35:41 -05:00
void PageHost::page_did_insert_clipboard_entry(String data, String presentation_style, String mime_type)
{
m_client.async_did_insert_clipboard_entry(move(data), move(presentation_style), move(mime_type));
}
LibWeb+LibWebView+WebContent: Add an Inspector IDL object to the Window This is an internal object that must be explicitly enabled by the chrome before it is added to the Window. The Inspector object will be used by a special WebView that will replace all chrome-specific inspector windows. The IDL defines methods that this WebView will need to inform the chrome of various events, such as the user clicking a DOM node.
2023-11-23 12:22:23 -05:00
void PageHost::inspector_did_load()
{
m_client.async_inspector_did_load();
}
void PageHost::inspector_did_select_dom_node(i32 node_id, Optional<Web::CSS::Selector::PseudoElement> const& pseudo_element)
{
m_client.async_inspector_did_select_dom_node(node_id, pseudo_element);
}
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 17:31:42 +02:00
}
Reference in a new issue Copy permalink