Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-26 10:54:15 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWebView/OutOfProcessWebView.cpp

773 lines
26 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
/*
LibGfx+WindowServer: Have WindowServer broadcast system font settings Instead of everybody getting their system fonts from Gfx::FontDatabase (where it's all hardcoded), they now get it from WindowServer. These are then plumbed into the usual Gfx::FontDatabase places so that the old default_font() and default_fixed_width_font() APIs keep working.
2021-05-21 18:10:23 +02:00
* Copyright (c) 2020-2021, Andreas Kling <kling@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
*/
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
#include "OutOfProcessWebView.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 "WebContentClient.h"
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
#include <AK/DeprecatedString.h>
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
#include <LibFileSystemAccessClient/Client.h>
LibWeb+WebContent: Support displaying tooltips in OOPWV
2021-03-30 12:10:06 -04:00
#include <LibGUI/Application.h>
LibWeb+WebContent: Keep track of screen rect It is now possible to get the up-to-date screen rect from a Web::Page.
2021-04-04 00:12:37 +02:00
#include <LibGUI/Desktop.h>
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
#include <LibGUI/Dialog.h>
LibWeb: Implement Window.prompt()
2021-02-20 12:05:18 +01:00
#include <LibGUI/InputBox.h>
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
#include <LibGUI/MessageBox.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 <LibGUI/Painter.h>
Everywhere: It's now "Foobar", not "FooBar", and not "foo bar" I hereby declare these to be full nouns that we don't split, neither by space, nor by underscore: - Breadcrumbbar - Coolbar - Menubar - Progressbar - Scrollbar - Statusbar - Taskbar - Toolbar This patch makes everything consistent by replacing every other variant of these with the proper one. :^)
2021-04-13 16:18:20 +02:00
#include <LibGUI/Scrollbar.h>
LibWeb: Make WebContentView show the hover hand over links :^)
2020-07-06 23:32:12 +02:00
#include <LibGUI/Window.h>
LibGfx: Move other font-related files to LibGfx/Font/
2022-04-09 09:28:38 +02:00
#include <LibGfx/Font/FontDatabase.h>
LibWeb: Fill OOPWV with the palette base color until we have pixels We were painting unfinished pixels while waiting for the WebContent process to render the page. This caused OOPWV to flicker black sometimes, which looked pretty bad. This way we still flicker, but at least we flicker with the correct palette color. :^)
2020-12-29 00:44:58 +01:00
#include <LibGfx/Palette.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>
LibWebView: Move OutOfProcessWebView to a new LibWebView library Also moves WebContentClient and the references to the generated IPC descriptions, since they are all components of OutOfProcessWebView. This patch has no functional changes.
2022-04-30 10:46:33 +02:00
REGISTER_WIDGET(WebView, OutOfProcessWebView)
LibWeb: Register the OutOfProcessWebView widget
2020-10-08 21:11:32 +01:00
LibWebView: Move OutOfProcessWebView to a new LibWebView library Also moves WebContentClient and the references to the generated IPC descriptions, since they are all components of OutOfProcessWebView. This patch has no functional changes.
2022-04-30 10:46:33 +02:00
namespace WebView {
LibWeb: Move OutOfProcessWebView into the Web namespace
2020-08-24 15:33:18 +04:30
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
OutOfProcessWebView::OutOfProcessWebView()
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: Don't show unnecessary scrollbars in WebContentView This behaves a little weird right now, and will probably require more coordination between the widget and the WebContent process.
2020-07-06 22:02:38 +02:00
set_should_hide_unnecessary_scrollbars(true);
LibGUI: Add Widget focus policies Every widget now has a GUI::FocusPolicy that determines how it can receive focus: - NoFocus: The widget is not focusable (default) - TabFocus: The widget can be focused using the tab key. - ClickFocus: The widget can be focused by clicking on it. - StrongFocus: Both of the above. For widgets that have a focus proxy, getting/setting the focus policy will affect the proxy instead.
2020-10-30 10:58:27 +01:00
set_focus_policy(GUI::FocusPolicy::StrongFocus);
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
create_client();
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
}
Libraries: Use default constructors/destructors in LibWeb https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-14 13:21:51 -06:00
OutOfProcessWebView::~OutOfProcessWebView() = default;
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: Defer the handling of WebContent process crashes Handling crashes synchronously is finicky since we're modifying the m_client_state struct while in a callback lambda owned by it. Let's avoid all the footguns here by simply using deferred_invoke() and handling the crash on next event loop iteration instead.
2021-02-22 11:07:40 +01:00
void OutOfProcessWebView::handle_web_content_process_crash()
{
create_client();
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(m_client_state.client);
LibWeb: Defer the handling of WebContent process crashes Handling crashes synchronously is finicky since we're modifying the m_client_state struct while in a callback lambda owned by it. Let's avoid all the footguns here by simply using deferred_invoke() and handling the crash on next event loop iteration instead.
2021-02-22 11:07:40 +01:00
// Don't keep a stale backup bitmap around.
m_backup_bitmap = nullptr;
handle_resize();
StringBuilder builder;
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
builder.append("<html><head><title>Crashed: "sv);
Everywhere: Rename to_{string => deprecated_string}() where applicable This will make it easier to support both string types at the same time while we convert code, and tracking down remaining uses. One big exception is Value::to_string() in LibJS, where the name is dictated by the ToString AO.
2022-12-06 01:12:49 +00:00
builder.append(escape_html_entities(m_url.to_deprecated_string()));
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
builder.append("</title></head><body>"sv);
builder.append("<h1>Web page crashed"sv);
LibWeb: Defer the handling of WebContent process crashes Handling crashes synchronously is finicky since we're modifying the m_client_state struct while in a callback lambda owned by it. Let's avoid all the footguns here by simply using deferred_invoke() and handling the crash on next event loop iteration instead.
2021-02-22 11:07:40 +01:00
if (!m_url.host().is_empty()) {
builder.appendff(" on {}", escape_html_entities(m_url.host()));
}
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
builder.append("</h1>"sv);
Everywhere: Rename to_{string => deprecated_string}() where applicable This will make it easier to support both string types at the same time while we convert code, and tracking down remaining uses. One big exception is Value::to_string() in LibJS, where the name is dictated by the ToString AO.
2022-12-06 01:12:49 +00:00
auto escaped_url = escape_html_entities(m_url.to_deprecated_string());
AK+LibWeb: Remove URL::to_string_encoded() This replaces URL::to_string_encoded() with to_string() and removes the former, since they are now equivalent.
2021-06-01 11:11:05 +02:00
builder.appendff("The web page <a href=\"{}\">{}</a> has crashed.<br><br>You can reload the page to try again.", escaped_url, escaped_url);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
builder.append("</body></html>"sv);
Everywhere: Rename to_{string => deprecated_string}() where applicable This will make it easier to support both string types at the same time while we convert code, and tracking down remaining uses. One big exception is Value::to_string() in LibJS, where the name is dictated by the ToString AO.
2022-12-06 01:12:49 +00:00
load_html(builder.to_deprecated_string(), m_url);
LibWeb: Defer the handling of WebContent process crashes Handling crashes synchronously is finicky since we're modifying the m_client_state struct while in a callback lambda owned by it. Let's avoid all the footguns here by simply using deferred_invoke() and handling the crash on next event loop iteration instead.
2021-02-22 11:07:40 +01:00
}
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
void OutOfProcessWebView::create_client()
{
m_client_state = {};
LibCore+LibIPC+Everywhere: Return Stream::LocalSocket from LocalServer This change unfortunately cannot be atomically made without a single commit changing everything. Most of the important changes are in LibIPC/Connection.cpp, LibIPC/ServerConnection.cpp and LibCore/LocalServer.cpp. The notable changes are: - IPCCompiler now generates the decode and decode_message functions such that they take a Core::Stream::LocalSocket instead of the socket fd. - IPC::Decoder now uses the receive_fd method of LocalSocket instead of doing system calls directly on the fd. - IPC::ConnectionBase and related classes now use the Stream API functions. - IPC::ServerConnection no longer constructs the socket itself; instead, a convenience macro, IPC_CLIENT_CONNECTION, is used in place of C_OBJECT and will generate a static try_create factory function for the ServerConnection subclass. The subclass is now responsible for passing the socket constructed in this function to its ServerConnection base; the socket is passed as the first argument to the constructor (as a NonnullOwnPtr<Core::Stream::LocalServer>) before any other arguments. - The functionality regarding taking over sockets from SystemServer has been moved to LibIPC/SystemServerTakeover.cpp. The Core::LocalSocket implementation of this functionality hasn't been deleted due to my intention of removing this class in the near future and to reduce noise on this (already quite noisy) PR.
2022-01-14 13:12:49 +00:00
m_client_state.client = WebContentClient::try_create(*this).release_value_but_fixme_should_propagate_errors();
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
m_client_state.client->on_web_content_process_crash = [this] {
Userland: Migrate to argument-less deferred_invoke Only one place used this argument and it was to hold on to a strong ref for the object. Since we already do that now, there's no need to keep this argument around since this can be easily captured. This commit contains no changes.
2021-08-30 18:12:48 +00:00
deferred_invoke([this] {
LibWeb: Defer the handling of WebContent process crashes Handling crashes synchronously is finicky since we're modifying the m_client_state struct while in a callback lambda owned by it. Let's avoid all the footguns here by simply using deferred_invoke() and handling the crash on next event loop iteration instead.
2021-02-22 11:07:40 +01:00
handle_web_content_process_crash();
});
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01: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
client().async_update_system_theme(Gfx::current_system_theme_buffer());
Userland+Base: Make the window titlebar font configurable separately Instead of defaulting to "bold variant of the system default font", let's allow the user to set any font they want as the titlebar font.
2022-07-31 18:41:07 +02:00
client().async_update_system_fonts(Gfx::FontDatabase::default_font_query(), Gfx::FontDatabase::fixed_width_font_query(), Gfx::FontDatabase::window_title_font_query());
WindowServer: Add initial support for rendering on multiple screens This allows WindowServer to use multiple framebuffer devices and compose the desktop with any arbitrary layout. Currently, it is assumed that it is configured contiguous and non-overlapping, but this should eventually be enforced. To make rendering efficient, each window now also tracks on which screens it needs to be rendered. This way we don't have to iterate all the windows for each screen but instead use the same rendering loop and then only render to the screen (or screens) that the window actually uses.
2021-06-13 06:16:06 -06:00
client().async_update_screen_rects(GUI::Desktop::the().rects(), GUI::Desktop::the().main_screen_index());
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::paint_event(GUI::PaintEvent& event)
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
{
LibWebView: Define the OOPWV's superclass in one place This lets us change it later without having to remember to update a bunch of uses. (More are coming in the next commit.)
2022-11-21 15:54:18 +00:00
Super::paint_event(event);
WebContent: Give the WebContentView a proper GUI::Frame look :^)
2020-07-04 23:27:36 +02:00
LibWeb: Don't attempt to create new bitmap for zero-size OOPWV It's not possible to construct a Gfx::Bitmap with empty size. Let the client know the new viewport rect and return before even attempting to create new front and back bitmaps. Also consider that we might have to paint the widget but not have a front/back bitmap available (e.g. when only part of a scrollbar is visible, and the inner rect is empty).
2020-11-08 15:07:57 +00:00
// If the available size is empty, we don't have a front or back bitmap to draw.
if (available_size().is_empty())
return;
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
GUI::Painter painter(*this);
painter.add_clip_rect(event.rect());
LibWeb: Fill OOPWV with the palette base color until we have pixels We were painting unfinished pixels while waiting for the WebContent process to render the page. This caused OOPWV to flicker black sometimes, which looked pretty bad. This way we still flicker, but at least we flicker with the correct palette color. :^)
2020-12-29 00:44:58 +01:00
LibWeb: Make a SharedBitmap struct for OOPWV bitmaps Instead of having separate members for "bitmap ID" and "bitmap", let's wrap them in a struct.
2021-09-17 14:30:49 +02:00
if (auto* bitmap = m_client_state.has_usable_bitmap ? m_client_state.front_bitmap.bitmap.ptr() : m_backup_bitmap.ptr()) {
LibWeb: Make OOPWV resizing flicker-free :^) When resizing, keep a copy of the last good bitmap we have, and keep using that until we receive a new one from the WebContent process.
2021-02-09 22:07:36 +01:00
painter.add_clip_rect(frame_inner_rect());
painter.translate(frame_thickness(), frame_thickness());
LibWebView: Add OOPWV "content scales to viewport" hint By setting this hint, you indicate to OOPWV that the content inside will scale itself to the viewport size. In such situations, it's fine for OOPWV to reuse a scaled version of an outdated backing store while the view is being resized.
2023-01-09 18:55:22 +01:00
if (m_content_scales_to_viewport)
painter.draw_scaled_bitmap(rect(), *bitmap, bitmap->rect());
else
painter.blit({ 0, 0 }, *bitmap, bitmap->rect());
LibWeb: Fill OOPWV with the palette base color until we have pixels We were painting unfinished pixels while waiting for the WebContent process to render the page. This caused OOPWV to flicker black sometimes, which looked pretty bad. This way we still flicker, but at least we flicker with the correct palette color. :^)
2020-12-29 00:44:58 +01:00
return;
}
LibWeb: Make OOPWV resizing flicker-free :^) When resizing, keep a copy of the last good bitmap we have, and keep using that until we receive a new one from the WebContent process.
2021-02-09 22:07:36 +01:00
painter.fill_rect(frame_inner_rect(), palette().base());
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 WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::resize_event(GUI::ResizeEvent& event)
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
{
LibWebView: Define the OOPWV's superclass in one place This lets us change it later without having to remember to update a bunch of uses. (More are coming in the next commit.)
2022-11-21 15:54:18 +00:00
Super::resize_event(event);
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
handle_resize();
}
WebContent: Use available size for bitmap (#2701) After adding the scrolling feature, content available space reduced and thus the bitmap size was always larger, than the inner size. This lead to the horizontal scrollbar always beeing engaged.
2020-07-05 12:45:56 +02:00
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
void OutOfProcessWebView::handle_resize()
{
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
client().async_set_viewport_rect(Gfx::IntRect({ horizontal_scrollbar().value(), vertical_scrollbar().value() }, available_size()));
LibWeb: Don't attempt to create new bitmap for zero-size OOPWV It's not possible to construct a Gfx::Bitmap with empty size. Let the client know the new viewport rect and return before even attempting to create new front and back bitmaps. Also consider that we might have to paint the widget but not have a front/back bitmap available (e.g. when only part of a scrollbar is visible, and the inner rect is empty).
2020-11-08 15:07:57 +00:00
LibWeb: Make OOPWV resizing flicker-free :^) When resizing, keep a copy of the last good bitmap we have, and keep using that until we receive a new one from the WebContent process.
2021-02-09 22:07:36 +01:00
if (m_client_state.has_usable_bitmap) {
// NOTE: We keep the outgoing front bitmap as a backup so we have something to paint until we get a new one.
LibWeb: Make a SharedBitmap struct for OOPWV bitmaps Instead of having separate members for "bitmap ID" and "bitmap", let's wrap them in a struct.
2021-09-17 14:30:49 +02:00
m_backup_bitmap = m_client_state.front_bitmap.bitmap;
LibWeb: Make OOPWV resizing flicker-free :^) When resizing, keep a copy of the last good bitmap we have, and keep using that until we receive a new one from the WebContent process.
2021-02-09 22:07:36 +01:00
}
LibWeb: Don't request WebContent repaint while we have repaints pending This prevents flickering by ensuring that WebContent is only ever painting into the back buffer bitmap. Without this change, it was possible for WebContent to paint into the front buffer bitmap.
2021-09-17 14:54:51 +02:00
if (m_client_state.front_bitmap.bitmap)
LibWeb: Make a SharedBitmap struct for OOPWV bitmaps Instead of having separate members for "bitmap ID" and "bitmap", let's wrap them in a struct.
2021-09-17 14:30:49 +02:00
client().async_remove_backing_store(m_client_state.front_bitmap.id);
LibWeb+WebContent: Use anonymous files for OOPWV backing stores To support this, the GUI process and the WebContent service will now coordinate their backing store bitmaps. Each backing store can be referred to by a serial ID, and we don't need to keep resending it as a file descriptor. We should probably do something similar in WindowServer. :^)
2021-01-16 23:15:32 +01:00
LibWeb: Don't request WebContent repaint while we have repaints pending This prevents flickering by ensuring that WebContent is only ever painting into the back buffer bitmap. Without this change, it was possible for WebContent to paint into the front buffer bitmap.
2021-09-17 14:54:51 +02:00
if (m_client_state.back_bitmap.bitmap)
LibWeb: Make a SharedBitmap struct for OOPWV bitmaps Instead of having separate members for "bitmap ID" and "bitmap", let's wrap them in a struct.
2021-09-17 14:30:49 +02:00
client().async_remove_backing_store(m_client_state.back_bitmap.id);
LibWeb+WebContent: Use anonymous files for OOPWV backing stores To support this, the GUI process and the WebContent service will now coordinate their backing store bitmaps. Each backing store can be referred to by a serial ID, and we don't need to keep resending it as a file descriptor. We should probably do something similar in WindowServer. :^)
2021-01-16 23:15:32 +01:00
LibWeb: Don't request WebContent repaint while we have repaints pending This prevents flickering by ensuring that WebContent is only ever painting into the back buffer bitmap. Without this change, it was possible for WebContent to paint into the front buffer bitmap.
2021-09-17 14:54:51 +02:00
m_client_state.front_bitmap = {};
m_client_state.back_bitmap = {};
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
m_client_state.has_usable_bitmap = false;
LibWeb: Don't assume backing store allocation succeeds on OOPWV resize Backing store allocation can fail if the requested size is too small, or too large. We should not crash when this happens. Fixes #3986.
2020-11-08 14:53:36 +01:00
LibWeb: Don't attempt to create new bitmap for zero-size OOPWV It's not possible to construct a Gfx::Bitmap with empty size. Let the client know the new viewport rect and return before even attempting to create new front and back bitmaps. Also consider that we might have to paint the widget but not have a front/back bitmap available (e.g. when only part of a scrollbar is visible, and the inner rect is empty).
2020-11-08 15:07:57 +00:00
if (available_size().is_empty())
return;
LibGfx: Use ErrorOr<T> for Bitmap::try_create_shareable()
2021-11-06 11:44:05 +01:00
if (auto new_bitmap_or_error = Gfx::Bitmap::try_create_shareable(Gfx::BitmapFormat::BGRx8888, available_size()); !new_bitmap_or_error.is_error()) {
m_client_state.front_bitmap.bitmap = new_bitmap_or_error.release_value();
LibWeb: Make a SharedBitmap struct for OOPWV bitmaps Instead of having separate members for "bitmap ID" and "bitmap", let's wrap them in a struct.
2021-09-17 14:30:49 +02:00
m_client_state.front_bitmap.id = m_client_state.next_bitmap_id++;
client().async_add_backing_store(m_client_state.front_bitmap.id, m_client_state.front_bitmap.bitmap->to_shareable_bitmap());
LibWeb: Don't assume backing store allocation succeeds on OOPWV resize Backing store allocation can fail if the requested size is too small, or too large. We should not crash when this happens. Fixes #3986.
2020-11-08 14:53:36 +01:00
}
LibGfx: Use ErrorOr<T> for Bitmap::try_create_shareable()
2021-11-06 11:44:05 +01:00
if (auto new_bitmap_or_error = Gfx::Bitmap::try_create_shareable(Gfx::BitmapFormat::BGRx8888, available_size()); !new_bitmap_or_error.is_error()) {
m_client_state.back_bitmap.bitmap = new_bitmap_or_error.release_value();
LibWeb: Make a SharedBitmap struct for OOPWV bitmaps Instead of having separate members for "bitmap ID" and "bitmap", let's wrap them in a struct.
2021-09-17 14:30:49 +02:00
m_client_state.back_bitmap.id = m_client_state.next_bitmap_id++;
client().async_add_backing_store(m_client_state.back_bitmap.id, m_client_state.back_bitmap.bitmap->to_shareable_bitmap());
LibWeb: Don't assume backing store allocation succeeds on OOPWV resize Backing store allocation can fail if the requested size is too small, or too large. We should not crash when this happens. Fixes #3986.
2020-11-08 14:53:36 +01:00
}
WebContent: Add double buffering to the WebContentView This removes the remaining flicker in the WebContentView widget and makes it feel pretty good to use it. :^) The increase in memory use is something we'll have to address in the future with more sophisticated solutions like tiling, etc.
2020-07-05 16:31:50 +02: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
request_repaint();
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
}
Browser: Implement zoom :^) Largely based on the Ladybird implementation in 0cc151b.
2023-01-12 18:31:14 +00:00
void OutOfProcessWebView::update_zoom()
{
client().async_set_device_pixels_per_css_pixel(m_device_pixel_ratio * m_zoom_level);
// FIXME: Refactor this into separate update_viewport_rect() + request_repaint() like in Ladybird
handle_resize();
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::keydown_event(GUI::KeyEvent& event)
LibWeb: Send key events to the WebContent process This makes contenteditable work in multi-process mode. :^)
2020-08-03 19:58:59 +02:00
{
LibWebView+WebContent: Propagate unconsumed input events out of OOPWV Since 9e2bd9d261a8c0c1b5eeafde95ca310efc667204, the OOPWV has been consuming all mouse and keyboard events, preventing action shortcuts from working. So let's fix that. :^) OOPWV now queues up input events, sending them one at a time to the WebContent process and waiting for the new `did_finish_handling_input_event(bool event_was_accepted) =|` IPC call before sending the next one. If the event was not accepted, OOPWV imitates the usual event bubbling: first passing the event to its superclass, then to its parent widget, and finally propagating to any Action shortcuts. With this, shortcuts like Ctrl+I to open Browser's JS console work again, except when a contenteditable field is selected. That's a whole separate stack of yaks. Co-authored-by: Zaggy1024 <zaggy1024@gmail.com>
2022-11-21 16:07:47 +00:00
enqueue_input_event(event);
LibWeb: Send key events to the WebContent process This makes contenteditable work in multi-process mode. :^)
2020-08-03 19:58:59 +02:00
}
LibWeb: Fire "keyup" events as well :^) This was easy, now that we have KeyboardEvent.
2021-09-28 15:39:35 +02:00
void OutOfProcessWebView::keyup_event(GUI::KeyEvent& event)
{
LibWebView+WebContent: Propagate unconsumed input events out of OOPWV Since 9e2bd9d261a8c0c1b5eeafde95ca310efc667204, the OOPWV has been consuming all mouse and keyboard events, preventing action shortcuts from working. So let's fix that. :^) OOPWV now queues up input events, sending them one at a time to the WebContent process and waiting for the new `did_finish_handling_input_event(bool event_was_accepted) =|` IPC call before sending the next one. If the event was not accepted, OOPWV imitates the usual event bubbling: first passing the event to its superclass, then to its parent widget, and finally propagating to any Action shortcuts. With this, shortcuts like Ctrl+I to open Browser's JS console work again, except when a contenteditable field is selected. That's a whole separate stack of yaks. Co-authored-by: Zaggy1024 <zaggy1024@gmail.com>
2022-11-21 16:07:47 +00:00
enqueue_input_event(event);
LibWeb: Fire "keyup" events as well :^) This was easy, now that we have KeyboardEvent.
2021-09-28 15:39:35 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::mousedown_event(GUI::MouseEvent& event)
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
{
LibWebView+WebContent: Propagate unconsumed input events out of OOPWV Since 9e2bd9d261a8c0c1b5eeafde95ca310efc667204, the OOPWV has been consuming all mouse and keyboard events, preventing action shortcuts from working. So let's fix that. :^) OOPWV now queues up input events, sending them one at a time to the WebContent process and waiting for the new `did_finish_handling_input_event(bool event_was_accepted) =|` IPC call before sending the next one. If the event was not accepted, OOPWV imitates the usual event bubbling: first passing the event to its superclass, then to its parent widget, and finally propagating to any Action shortcuts. With this, shortcuts like Ctrl+I to open Browser's JS console work again, except when a contenteditable field is selected. That's a whole separate stack of yaks. Co-authored-by: Zaggy1024 <zaggy1024@gmail.com>
2022-11-21 16:07:47 +00:00
enqueue_input_event(event);
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::mouseup_event(GUI::MouseEvent& event)
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
{
LibWebView+WebContent: Propagate unconsumed input events out of OOPWV Since 9e2bd9d261a8c0c1b5eeafde95ca310efc667204, the OOPWV has been consuming all mouse and keyboard events, preventing action shortcuts from working. So let's fix that. :^) OOPWV now queues up input events, sending them one at a time to the WebContent process and waiting for the new `did_finish_handling_input_event(bool event_was_accepted) =|` IPC call before sending the next one. If the event was not accepted, OOPWV imitates the usual event bubbling: first passing the event to its superclass, then to its parent widget, and finally propagating to any Action shortcuts. With this, shortcuts like Ctrl+I to open Browser's JS console work again, except when a contenteditable field is selected. That's a whole separate stack of yaks. Co-authored-by: Zaggy1024 <zaggy1024@gmail.com>
2022-11-21 16:07:47 +00:00
enqueue_input_event(event);
Browser: Go back/forward when pressing back/forward mouse buttons This currently doesn't work when running Serenity through QEMU, as it doesn't pass the side button events over to Serenity due to some bug or missing feature.
2022-11-10 20:24:45 +01:00
if (event.button() == GUI::MouseButton::Backward && on_back_button) {
on_back_button();
} else if (event.button() == GUI::MouseButton::Forward && on_forward_button) {
on_forward_button();
}
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::mousemove_event(GUI::MouseEvent& event)
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
{
LibWebView+WebContent: Propagate unconsumed input events out of OOPWV Since 9e2bd9d261a8c0c1b5eeafde95ca310efc667204, the OOPWV has been consuming all mouse and keyboard events, preventing action shortcuts from working. So let's fix that. :^) OOPWV now queues up input events, sending them one at a time to the WebContent process and waiting for the new `did_finish_handling_input_event(bool event_was_accepted) =|` IPC call before sending the next one. If the event was not accepted, OOPWV imitates the usual event bubbling: first passing the event to its superclass, then to its parent widget, and finally propagating to any Action shortcuts. With this, shortcuts like Ctrl+I to open Browser's JS console work again, except when a contenteditable field is selected. That's a whole separate stack of yaks. Co-authored-by: Zaggy1024 <zaggy1024@gmail.com>
2022-11-21 16:07:47 +00:00
enqueue_input_event(event);
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
}
LibWeb: Plumb wheel events from widget layer to EventHandler
2021-02-22 19:45:41 +01:00
void OutOfProcessWebView::mousewheel_event(GUI::MouseEvent& event)
{
LibWebView+WebContent: Propagate unconsumed input events out of OOPWV Since 9e2bd9d261a8c0c1b5eeafde95ca310efc667204, the OOPWV has been consuming all mouse and keyboard events, preventing action shortcuts from working. So let's fix that. :^) OOPWV now queues up input events, sending them one at a time to the WebContent process and waiting for the new `did_finish_handling_input_event(bool event_was_accepted) =|` IPC call before sending the next one. If the event was not accepted, OOPWV imitates the usual event bubbling: first passing the event to its superclass, then to its parent widget, and finally propagating to any Action shortcuts. With this, shortcuts like Ctrl+I to open Browser's JS console work again, except when a contenteditable field is selected. That's a whole separate stack of yaks. Co-authored-by: Zaggy1024 <zaggy1024@gmail.com>
2022-11-21 16:07:47 +00:00
enqueue_input_event(event);
LibWeb: Plumb wheel events from widget layer to EventHandler
2021-02-22 19:45:41 +01:00
}
LibWeb+LibWebView+WebContent: Get doubleclick events from LibGUI
2022-06-14 19:38:32 +02:00
void OutOfProcessWebView::doubleclick_event(GUI::MouseEvent& event)
{
LibWebView+WebContent: Propagate unconsumed input events out of OOPWV Since 9e2bd9d261a8c0c1b5eeafde95ca310efc667204, the OOPWV has been consuming all mouse and keyboard events, preventing action shortcuts from working. So let's fix that. :^) OOPWV now queues up input events, sending them one at a time to the WebContent process and waiting for the new `did_finish_handling_input_event(bool event_was_accepted) =|` IPC call before sending the next one. If the event was not accepted, OOPWV imitates the usual event bubbling: first passing the event to its superclass, then to its parent widget, and finally propagating to any Action shortcuts. With this, shortcuts like Ctrl+I to open Browser's JS console work again, except when a contenteditable field is selected. That's a whole separate stack of yaks. Co-authored-by: Zaggy1024 <zaggy1024@gmail.com>
2022-11-21 16:07:47 +00:00
enqueue_input_event(event);
LibWeb+LibWebView+WebContent: Get doubleclick events from LibGUI
2022-06-14 19:38:32 +02:00
}
LibWeb: Handle theme change event in OutOfProcessWebView
2020-10-08 22:13:54 +01:00
void OutOfProcessWebView::theme_change_event(GUI::ThemeChangeEvent& event)
{
LibWebView: Define the OOPWV's superclass in one place This lets us change it later without having to remember to update a bunch of uses. (More are coming in the next commit.)
2022-11-21 15:54:18 +00:00
Super::theme_change_event(event);
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
client().async_update_system_theme(Gfx::current_system_theme_buffer());
LibWeb: Handle theme change event in OutOfProcessWebView
2020-10-08 22:13:54 +01:00
request_repaint();
}
WindowServer: Add initial support for rendering on multiple screens This allows WindowServer to use multiple framebuffer devices and compose the desktop with any arbitrary layout. Currently, it is assumed that it is configured contiguous and non-overlapping, but this should eventually be enforced. To make rendering efficient, each window now also tracks on which screens it needs to be rendered. This way we don't have to iterate all the windows for each screen but instead use the same rendering loop and then only render to the screen (or screens) that the window actually uses.
2021-06-13 06:16:06 -06:00
void OutOfProcessWebView::screen_rects_change_event(GUI::ScreenRectsChangeEvent& event)
LibWeb+WebContent: Keep track of screen rect It is now possible to get the up-to-date screen rect from a Web::Page.
2021-04-04 00:12:37 +02:00
{
WindowServer: Add initial support for rendering on multiple screens This allows WindowServer to use multiple framebuffer devices and compose the desktop with any arbitrary layout. Currently, it is assumed that it is configured contiguous and non-overlapping, but this should eventually be enforced. To make rendering efficient, each window now also tracks on which screens it needs to be rendered. This way we don't have to iterate all the windows for each screen but instead use the same rendering loop and then only render to the screen (or screens) that the window actually uses.
2021-06-13 06:16:06 -06:00
client().async_update_screen_rects(event.rects(), event.main_screen_index());
LibWeb+WebContent: Keep track of screen rect It is now possible to get the up-to-date screen rect from a Web::Page.
2021-04-04 00:12:37 +02:00
}
LibWeb+WebContent: Use anonymous files for OOPWV backing stores To support this, the GUI process and the WebContent service will now coordinate their backing store bitmaps. Each backing store can be referred to by a serial ID, and we don't need to keep resending it as a file descriptor. We should probably do something similar in WindowServer. :^)
2021-01-16 23:15:32 +01:00
void OutOfProcessWebView::notify_server_did_paint(Badge<WebContentClient>, i32 bitmap_id)
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: Make a SharedBitmap struct for OOPWV bitmaps Instead of having separate members for "bitmap ID" and "bitmap", let's wrap them in a struct.
2021-09-17 14:30:49 +02:00
if (m_client_state.back_bitmap.id == bitmap_id) {
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
m_client_state.has_usable_bitmap = true;
LibWeb: Don't request WebContent repaint while we have repaints pending This prevents flickering by ensuring that WebContent is only ever painting into the back buffer bitmap. Without this change, it was possible for WebContent to paint into the front buffer bitmap.
2021-09-17 14:54:51 +02:00
m_client_state.back_bitmap.pending_paints--;
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
swap(m_client_state.back_bitmap, m_client_state.front_bitmap);
LibWeb: Make OOPWV resizing flicker-free :^) When resizing, keep a copy of the last good bitmap we have, and keep using that until we receive a new one from the WebContent process.
2021-02-09 22:07:36 +01:00
// We don't need the backup bitmap anymore, so drop it.
m_backup_bitmap = nullptr;
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
update();
LibWeb: Coalesce nested repaint requests instead of swallowing them Previously we would ignore repaint requests that came in via OOPWV while the WebContent process was busy with a previous paint request. This caused some easy-to-trigger bugs where the painted content would be "one paint behind", especially noticeable when scrolling.
2021-10-18 10:25:13 +02:00
if (m_client_state.got_repaint_requests_while_painting) {
m_client_state.got_repaint_requests_while_painting = false;
request_repaint();
}
WebContent: Add double buffering to the WebContentView This removes the remaining flicker in the WebContentView widget and makes it feel pretty good to use it. :^) The increase in memory use is something we'll have to address in the future with more sophisticated solutions like tiling, etc.
2020-07-05 16:31:50 +02:00
}
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
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_did_invalidate_content_rect(Badge<WebContentClient>, [[maybe_unused]] Gfx::IntRect 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
{
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
request_repaint();
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_change_selection(Badge<WebContentClient>)
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
{
request_repaint();
}
LibWeb: Support setting the cursor in OutOfProcessWebView
2021-02-27 21:12:12 +00:00
void OutOfProcessWebView::notify_server_did_request_cursor_change(Badge<WebContentClient>, Gfx::StandardCursor cursor)
{
set_override_cursor(cursor);
}
Meta+Userland: Pass Gfx::IntSize by value Just two ints like Gfx::IntPoint.
2022-12-06 21:35:32 +00:00
void OutOfProcessWebView::notify_server_did_layout(Badge<WebContentClient>, Gfx::IntSize content_size)
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
{
set_content_size(content_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
void OutOfProcessWebView::notify_server_did_change_title(Badge<WebContentClient>, 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
{
if (on_title_change)
on_title_change(title);
}
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 OutOfProcessWebView::notify_server_did_request_scroll(Badge<WebContentClient>, 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
{
Everywhere: Use 'increase_slider_by()' method from AbstractSlider This method help us to avoid repeating the pattern 'set_value(value() + delta)'.
2021-12-28 21:47:26 -06:00
horizontal_scrollbar().increase_slider_by(x_delta);
vertical_scrollbar().increase_slider_by(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
}
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
void OutOfProcessWebView::notify_server_did_request_scroll_to(Badge<WebContentClient>, Gfx::IntPoint 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
{
horizontal_scrollbar().set_value(scroll_position.x());
vertical_scrollbar().set_value(scroll_position.y());
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_did_request_scroll_into_view(Badge<WebContentClient>, Gfx::IntRect 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
{
scroll_into_view(rect, true, true);
}
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
void OutOfProcessWebView::notify_server_did_enter_tooltip_area(Badge<WebContentClient>, Gfx::IntPoint, DeprecatedString const& title)
LibWeb+WebContent: Support displaying tooltips in OOPWV
2021-03-30 12:10:06 -04:00
{
GUI::Application::the()->show_tooltip(title, nullptr);
}
void OutOfProcessWebView::notify_server_did_leave_tooltip_area(Badge<WebContentClient>)
{
GUI::Application::the()->hide_tooltip();
}
LibWeb: Add the Web::URL namespace and move URLEncoder to it This namespace will be used for all interfaces defined in the URL specification, like URL and URLSearchParams. This has the unfortunate side-effect of requiring us to use the fully qualified AK::URL name whenever we want to refer to the AK class, so this commit also fixes all such references.
2021-09-13 00:33:23 +03:00
void OutOfProcessWebView::notify_server_did_hover_link(Badge<WebContentClient>, const AK::URL& 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
{
if (on_link_hover)
on_link_hover(url);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_unhover_link(Badge<WebContentClient>)
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
{
LibWeb: Use widget override cursors
2020-09-11 14:28:05 +02:00
set_override_cursor(Gfx::StandardCursor::None);
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
if (on_link_hover)
on_link_hover({});
}
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 OutOfProcessWebView::notify_server_did_click_link(Badge<WebContentClient>, const AK::URL& url, DeprecatedString const& target, unsigned int 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
{
if (on_link_click)
on_link_click(url, target, modifiers);
}
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 OutOfProcessWebView::notify_server_did_middle_click_link(Badge<WebContentClient>, const AK::URL& url, DeprecatedString const& target, unsigned int 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
{
if (on_link_middle_click)
on_link_middle_click(url, target, modifiers);
}
Browser: Replace history entry if loading URL because of a redirect We now replace the current history entry if the page-load has been caused because of a redirect. This makes it able to traverse the history if one of the entries redirects you, which previously caused an infinite history traversion loop.
2022-11-24 01:18:11 +01:00
void OutOfProcessWebView::notify_server_did_start_loading(Badge<WebContentClient>, const AK::URL& url, bool is_redirect)
LibWeb: Make the WebContentView::on_load_start hook actually work :^)
2020-07-06 21:58:16 +02:00
{
LibWebView: Update OOPWV's URL when a page starts/finishes loading If the page's URL is changed from within the WebContent process (e.g. window.location.href is set from JavaScript, or a navigation is started from WebDriver), we would not store the URL at all within OOPWV. This prevented actions like reloading from working properly, as the browser would reload whatever URL was previously entered in the URL box.
2022-11-19 11:40:18 -05:00
m_url = url;
LibWeb: Make the WebContentView::on_load_start hook actually work :^)
2020-07-06 21:58:16 +02:00
if (on_load_start)
Browser: Replace history entry if loading URL because of a redirect We now replace the current history entry if the page-load has been caused because of a redirect. This makes it able to traverse the history if one of the entries redirects you, which previously caused an infinite history traversion loop.
2022-11-24 01:18:11 +01:00
on_load_start(url, is_redirect);
LibWeb: Make the WebContentView::on_load_start hook actually work :^)
2020-07-06 21:58:16 +02:00
}
LibWeb: Add the Web::URL namespace and move URLEncoder to it This namespace will be used for all interfaces defined in the URL specification, like URL and URLSearchParams. This has the unfortunate side-effect of requiring us to use the fully qualified AK::URL name whenever we want to refer to the AK class, so this commit also fixes all such references.
2021-09-13 00:33:23 +03:00
void OutOfProcessWebView::notify_server_did_finish_loading(Badge<WebContentClient>, const AK::URL& 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
{
LibWebView: Update OOPWV's URL when a page starts/finishes loading If the page's URL is changed from within the WebContent process (e.g. window.location.href is set from JavaScript, or a navigation is started from WebDriver), we would not store the URL at all within OOPWV. This prevented actions like reloading from working properly, as the browser would reload whatever URL was previously entered in the URL box.
2022-11-19 11:40:18 -05:00
m_url = 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
if (on_load_finish)
on_load_finish(url);
}
LibWebView+WebContent: Add IPCs to navigate the browser's history
2022-11-11 13:33:11 -05:00
void OutOfProcessWebView::notify_server_did_request_navigate_back(Badge<WebContentClient>)
{
if (on_navigate_back)
on_navigate_back();
}
void OutOfProcessWebView::notify_server_did_request_navigate_forward(Badge<WebContentClient>)
{
if (on_navigate_forward)
on_navigate_forward();
}
void OutOfProcessWebView::notify_server_did_request_refresh(Badge<WebContentClient>)
{
if (on_refresh)
on_refresh();
}
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
void OutOfProcessWebView::notify_server_did_request_context_menu(Badge<WebContentClient>, Gfx::IntPoint 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
{
if (on_context_menu_request)
on_context_menu_request(screen_relative_rect().location().translated(to_widget_position(content_position)));
}
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
void OutOfProcessWebView::notify_server_did_request_link_context_menu(Badge<WebContentClient>, Gfx::IntPoint content_position, const AK::URL& url, DeprecatedString const&, unsigned)
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
{
if (on_link_context_menu_request)
on_link_context_menu_request(url, screen_relative_rect().location().translated(to_widget_position(content_position)));
}
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
void OutOfProcessWebView::notify_server_did_request_image_context_menu(Badge<WebContentClient>, Gfx::IntPoint content_position, const AK::URL& url, DeprecatedString const&, unsigned, Gfx::ShareableBitmap const& bitmap)
LibWeb+WebContent: Support image context menus in OOPWV You can now right-click images in web content and get a context menu.
2021-04-11 16:49:25 +02:00
{
if (on_image_context_menu_request)
on_image_context_menu_request(url, screen_relative_rect().location().translated(to_widget_position(content_position)), bitmap);
}
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 OutOfProcessWebView::notify_server_did_request_alert(Badge<WebContentClient>, DeprecatedString const& message)
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
{
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
m_dialog = GUI::MessageBox::construct(window(), message, "Alert"sv, GUI::MessageBox::Type::Information, GUI::MessageBox::InputType::OK);
m_dialog->set_icon(window()->icon());
m_dialog->exec();
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
client().async_alert_closed();
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
m_dialog = nullptr;
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
}
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 OutOfProcessWebView::notify_server_did_request_confirm(Badge<WebContentClient>, DeprecatedString const& message)
LibWeb+WebContent: Support window.confirm() in OOPWV
2021-02-10 08:48:28 +01:00
{
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
m_dialog = GUI::MessageBox::construct(window(), message, "Confirm"sv, GUI::MessageBox::Type::Warning, GUI::MessageBox::InputType::OKCancel);
m_dialog->set_icon(window()->icon());
client().async_confirm_closed(m_dialog->exec() == GUI::Dialog::ExecResult::OK);
m_dialog = nullptr;
LibWeb+WebContent: Support window.confirm() in OOPWV
2021-02-10 08:48:28 +01: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 OutOfProcessWebView::notify_server_did_request_prompt(Badge<WebContentClient>, DeprecatedString const& message, DeprecatedString const& default_)
LibWeb: Implement Window.prompt()
2021-02-20 12:05:18 +01:00
{
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
m_dialog = GUI::InputBox::construct(window(), default_, message, "Prompt"sv, StringView {}, GUI::InputType::Text);
m_dialog->set_icon(window()->icon());
if (m_dialog->exec() == GUI::InputBox::ExecResult::OK)
client().async_prompt_closed(static_cast<GUI::InputBox&>(*m_dialog).text_value());
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
else
client().async_prompt_closed({});
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
m_dialog = nullptr;
}
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 OutOfProcessWebView::notify_server_did_request_set_prompt_text(Badge<WebContentClient>, DeprecatedString const& message)
LibWeb+LibWebView+WebContent+WebDriver: Implement Send Alert Text
2022-11-16 08:57:05 -05:00
{
if (m_dialog && is<GUI::InputBox>(*m_dialog))
static_cast<GUI::InputBox&>(*m_dialog).set_text_value(message);
}
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
void OutOfProcessWebView::notify_server_did_request_accept_dialog(Badge<WebContentClient>)
{
if (m_dialog)
m_dialog->done(GUI::Dialog::ExecResult::OK);
}
void OutOfProcessWebView::notify_server_did_request_dismiss_dialog(Badge<WebContentClient>)
{
if (m_dialog)
m_dialog->done(GUI::Dialog::ExecResult::Cancel);
LibWeb: Implement Window.prompt()
2021-02-20 12:05:18 +01: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 OutOfProcessWebView::notify_server_did_get_source(const AK::URL& url, DeprecatedString const& source)
LibWeb: Added get source functionality and hook event
2021-02-23 06:17:23 -06:00
{
if (on_get_source)
on_get_source(url, source);
}
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 OutOfProcessWebView::notify_server_did_get_dom_tree(DeprecatedString const& dom_tree)
LibWeb+WebContent: Add IPC flow for Inspect DOM Tree Add `inspect_dom_tree` to WebContentServer and 'did_get_dom_tree' to WebContentClient. These two async methods form a request & response for requesting a JSON representation of the Content's DOM tree.
2021-06-07 16:35:10 +01:00
{
if (on_get_dom_tree)
on_get_dom_tree(dom_tree);
}
Browser+WebContent: Fixup some DOM inspector weirdness This fixes a few things I noticed whilst working on the inspector for Ladybird. 1. The computed and resolved values were being passed swapped around from the inspect_dom_node() IPC call. I.e. computed values were passed as resolved values and vice versa. This was then fixed by swapping them again in the InspectorWidget (two errors canceled out). 2. Resolved values were called "specified values" seemingly only in the inspect_dom_node() IPC calls. This was a little confusing so I've renamed them to back to "resolved values" for consistency. 3. The inspector took and stored the DOM JSON strings unnecessarily, all the models immediately parse the JSON and don't need the strings to hang around.
2022-12-18 22:49:09 +00:00
void OutOfProcessWebView::notify_server_did_get_dom_node_properties(i32 node_id, DeprecatedString const& computed_style, DeprecatedString const& resolved_style, DeprecatedString const& custom_properties, DeprecatedString const& node_box_sizing)
LibWeb+WebContent: Implement asynchronous DOM Node properties call This lets us "push" a new style-properties list to the DOM Inspector, for example when JS changes the style of the inspected node.
2021-08-27 12:47:30 +01:00
{
if (on_get_dom_node_properties)
Browser+WebContent: Fixup some DOM inspector weirdness This fixes a few things I noticed whilst working on the inspector for Ladybird. 1. The computed and resolved values were being passed swapped around from the inspect_dom_node() IPC call. I.e. computed values were passed as resolved values and vice versa. This was then fixed by swapping them again in the InspectorWidget (two errors canceled out). 2. Resolved values were called "specified values" seemingly only in the inspect_dom_node() IPC calls. This was a little confusing so I've renamed them to back to "resolved values" for consistency. 3. The inspector took and stored the DOM JSON strings unnecessarily, all the models immediately parse the JSON and don't need the strings to hang around.
2022-12-18 22:49:09 +00:00
on_get_dom_node_properties(node_id, computed_style, resolved_style, custom_properties, node_box_sizing);
LibWeb+WebContent: Implement asynchronous DOM Node properties call This lets us "push" a new style-properties list to the DOM Inspector, for example when JS changes the style of the inspected node.
2021-08-27 12:47:30 +01:00
}
LibWeb+WebContent: Add new console-message IPC calls This patch introduces three new IPC calls for WebContent: - `Client::did_output_js_console_message(index)`: Notifies the client that a new console message was logged. - `Server::js_console_request_messages(start_index)`: Ask the server for console messages starting at the given index. - `Client::did_get_js_console_messages(start_index, types, messages)`: Send the client the messages they requested. This mechanism will replace the current `Client::did_js_console_output()` call in the next few commits. This will allow us to display messages in the console that happened before the console was opened.
2021-09-04 11:14:25 +01:00
void OutOfProcessWebView::notify_server_did_output_js_console_message(i32 message_index)
{
if (on_js_console_new_message)
on_js_console_new_message(message_index);
}
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 OutOfProcessWebView::notify_server_did_get_js_console_messages(i32 start_index, Vector<DeprecatedString> const& message_types, Vector<DeprecatedString> const& messages)
LibWeb+WebContent: Add new console-message IPC calls This patch introduces three new IPC calls for WebContent: - `Client::did_output_js_console_message(index)`: Notifies the client that a new console message was logged. - `Server::js_console_request_messages(start_index)`: Ask the server for console messages starting at the given index. - `Client::did_get_js_console_messages(start_index, types, messages)`: Send the client the messages they requested. This mechanism will replace the current `Client::did_js_console_output()` call in the next few commits. This will allow us to display messages in the console that happened before the console was opened.
2021-09-04 11:14:25 +01:00
{
if (on_get_js_console_messages)
on_get_js_console_messages(start_index, message_types, messages);
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_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
{
if (on_favicon_change)
on_favicon_change(favicon);
}
LibWebView+WebContent: Add IPC to get all cookies for a document's URL
2022-11-11 09:23:24 -05:00
Vector<Web::Cookie::Cookie> OutOfProcessWebView::notify_server_did_request_all_cookies(Badge<WebContentClient>, AK::URL const& url)
{
if (on_get_all_cookies)
return on_get_all_cookies(url);
return {};
}
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> OutOfProcessWebView::notify_server_did_request_named_cookie(Badge<WebContentClient>, AK::URL const& url, DeprecatedString const& name)
LibWebView+WebContent: Add IPC to get a document's named cookie
2022-11-11 09:46:56 -05:00
{
if (on_get_named_cookie)
return on_get_named_cookie(url, name);
return {};
}
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 OutOfProcessWebView::notify_server_did_request_cookie(Badge<WebContentClient>, const AK::URL& url, Web::Cookie::Source source)
LibWeb+WebContent: Hook document.cookie to the backend cookie storage
2021-04-11 10:54:11 -04:00
{
if (on_get_cookie)
Browser+LibWeb+WebContent: Track the source of document.cookie requests To implement the HttpOnly attribute, the CookieJar needs to know where a request originated from. Namely, it needs to distinguish between HTTP / non-HTTP (i.e. JavaScript) requests. When the HttpOnly attribute is set, requests from JavaScript are to be blocked.
2021-04-13 17:30:41 -04:00
return on_get_cookie(url, source);
LibWeb+WebContent: Hook document.cookie to the backend cookie storage
2021-04-11 10:54:11 -04:00
return {};
}
LibWebView: Move OutOfProcessWebView to a new LibWebView library Also moves WebContentClient and the references to the generated IPC descriptions, since they are all components of OutOfProcessWebView. This patch has no functional changes.
2022-04-30 10:46:33 +02:00
void OutOfProcessWebView::notify_server_did_set_cookie(Badge<WebContentClient>, const AK::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
{
if (on_set_cookie)
Browser+LibWeb+WebContent: Track the source of document.cookie requests To implement the HttpOnly attribute, the CookieJar needs to know where a request originated from. Namely, it needs to distinguish between HTTP / non-HTTP (i.e. JavaScript) requests. When the HttpOnly attribute is set, requests from JavaScript are to be blocked.
2021-04-13 17:30:41 -04:00
on_set_cookie(url, cookie, source);
Browser: Show currently loading host and remaining resource count
2022-02-20 17:03:39 -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
void OutOfProcessWebView::notify_server_did_update_cookie(Badge<WebContentClient>, Web::Cookie::Cookie const& cookie)
LibWebView+WebContent: Add IPC to update a document's cookie
2022-11-11 11:18:40 -05:00
{
if (on_update_cookie)
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
on_update_cookie(cookie);
LibWebView+WebContent: Add IPC to update a document's cookie
2022-11-11 11:18:40 -05:00
}
Browser: Show currently loading host and remaining resource count
2022-02-20 17:03:39 -05:00
void OutOfProcessWebView::notify_server_did_update_resource_count(i32 count_waiting)
{
if (on_resource_status_change)
on_resource_status_change(count_waiting);
LibWeb+WebContent: Hook document.cookie to the backend cookie storage
2021-04-11 10:54:11 -04:00
}
Browser+LibWebView+WebContent: Add IPC to re[store,size,position] window Requests to restore, resize, and reposition Browser windows will be coming from the WebContent process rather than the WebDriver process. Add hooks to propagate these requests back up to the Browser. The spec notes "The specification does not guarantee that the resulting window size will exactly match that which was requested", so these new methods return the actual new size/position.
2022-11-09 09:51:39 -05:00
void OutOfProcessWebView::notify_server_did_request_restore_window()
{
if (on_restore_window)
on_restore_window();
}
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 OutOfProcessWebView::notify_server_did_request_reposition_window(Gfx::IntPoint position)
Browser+LibWebView+WebContent: Add IPC to re[store,size,position] window Requests to restore, resize, and reposition Browser windows will be coming from the WebContent process rather than the WebDriver process. Add hooks to propagate these requests back up to the Browser. The spec notes "The specification does not guarantee that the resulting window size will exactly match that which was requested", so these new methods return the actual new size/position.
2022-11-09 09:51:39 -05:00
{
if (on_reposition_window)
return on_reposition_window(position);
return {};
}
Meta+Userland: Pass Gfx::IntSize by value Just two ints like Gfx::IntPoint.
2022-12-06 21:35:32 +00:00
Gfx::IntSize OutOfProcessWebView::notify_server_did_request_resize_window(Gfx::IntSize size)
Browser+LibWebView+WebContent: Add IPC to re[store,size,position] window Requests to restore, resize, and reposition Browser windows will be coming from the WebContent process rather than the WebDriver process. Add hooks to propagate these requests back up to the Browser. The spec notes "The specification does not guarantee that the resulting window size will exactly match that which was requested", so these new methods return the actual new size/position.
2022-11-09 09:51:39 -05:00
{
if (on_resize_window)
return on_resize_window(size);
return {};
}
Browser+LibWebView+WebContent: Add IPC to minimize and maximize window Requests to maximize and minimize Browser windows will be coming from the WebContent process rather than the WebDriver process. Add hooks to propagate these requests back up to the Browser.
2022-11-09 10:04:09 -05:00
Gfx::IntRect OutOfProcessWebView::notify_server_did_request_maximize_window()
{
if (on_maximize_window)
return on_maximize_window();
return {};
}
Gfx::IntRect OutOfProcessWebView::notify_server_did_request_minimize_window()
{
if (on_minimize_window)
return on_minimize_window();
return {};
}
WebDriver: Implement `POST /session/{id}/window/fullscreen` endpoint
2022-11-09 19:09:17 +01:00
Gfx::IntRect OutOfProcessWebView::notify_server_did_request_fullscreen_window()
{
if (on_fullscreen_window)
return on_fullscreen_window();
return {};
}
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 OutOfProcessWebView::notify_server_did_request_file(Badge<WebContentClient>, DeprecatedString const& path, i32 request_id)
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
{
LibWebView: Port to Core::Stream
2023-01-08 23:20:44 +01:00
auto file = FileSystemAccessClient::Client::the().request_file_read_only_approved(window(), path);
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
if (file.is_error())
client().async_handle_file_return(file.error().code(), {}, request_id);
else
LibWebView: Port to Core::Stream
2023-01-08 23:20:44 +01:00
client().async_handle_file_return(0, IPC::File(file.value().stream()), request_id);
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: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::did_scroll()
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
{
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
client().async_set_viewport_rect(visible_content_rect());
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
request_repaint();
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::request_repaint()
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: Don't send OOPWV repaint requests for views without backing This fixes an assertion in TextEditor when changing the system theme, since that would trigger a repaint request for the HTML preview widget which may not have backing unless it's actually been used to perform HTML (or Markdown) preview yet.
2020-10-24 12:28:38 +02:00
// If this widget was instantiated but not yet added to a window,
// it won't have a back bitmap yet, so we can just skip repaint requests.
LibWeb: Make a SharedBitmap struct for OOPWV bitmaps Instead of having separate members for "bitmap ID" and "bitmap", let's wrap them in a struct.
2021-09-17 14:30:49 +02:00
if (!m_client_state.back_bitmap.bitmap)
LibWeb: Don't send OOPWV repaint requests for views without backing This fixes an assertion in TextEditor when changing the system theme, since that would trigger a repaint request for the HTML preview widget which may not have backing unless it's actually been used to perform HTML (or Markdown) preview yet.
2020-10-24 12:28:38 +02:00
return;
LibWeb: Don't request WebContent repaint while we have repaints pending This prevents flickering by ensuring that WebContent is only ever painting into the back buffer bitmap. Without this change, it was possible for WebContent to paint into the front buffer bitmap.
2021-09-17 14:54:51 +02:00
// Don't request a repaint until pending paint requests have finished.
LibWeb: Coalesce nested repaint requests instead of swallowing them Previously we would ignore repaint requests that came in via OOPWV while the WebContent process was busy with a previous paint request. This caused some easy-to-trigger bugs where the painted content would be "one paint behind", especially noticeable when scrolling.
2021-10-18 10:25:13 +02:00
if (m_client_state.back_bitmap.pending_paints) {
m_client_state.got_repaint_requests_while_painting = true;
LibWeb: Don't request WebContent repaint while we have repaints pending This prevents flickering by ensuring that WebContent is only ever painting into the back buffer bitmap. Without this change, it was possible for WebContent to paint into the front buffer bitmap.
2021-09-17 14:54:51 +02:00
return;
LibWeb: Coalesce nested repaint requests instead of swallowing them Previously we would ignore repaint requests that came in via OOPWV while the WebContent process was busy with a previous paint request. This caused some easy-to-trigger bugs where the painted content would be "one paint behind", especially noticeable when scrolling.
2021-10-18 10:25:13 +02:00
}
LibWeb: Don't request WebContent repaint while we have repaints pending This prevents flickering by ensuring that WebContent is only ever painting into the back buffer bitmap. Without this change, it was possible for WebContent to paint into the front buffer bitmap.
2021-09-17 14:54:51 +02:00
m_client_state.back_bitmap.pending_paints++;
LibWeb: Make a SharedBitmap struct for OOPWV bitmaps Instead of having separate members for "bitmap ID" and "bitmap", let's wrap them in a struct.
2021-09-17 14:30:49 +02:00
client().async_paint(m_client_state.back_bitmap.bitmap->rect().translated(horizontal_scrollbar().value(), vertical_scrollbar().value()), m_client_state.back_bitmap.id);
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
}
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 OutOfProcessWebView::js_console_input(DeprecatedString const& js_source)
LibWeb: Add in all of the plumbing required to use the JS console over IPC
2021-02-27 21:47:14 -06:00
{
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 15:52:56 +02:00
client().async_js_console_input(js_source);
LibWeb: Add in all of the plumbing required to use the JS console over IPC
2021-02-27 21:47:14 -06:00
}
LibWeb+WebContent: Add new console-message IPC calls This patch introduces three new IPC calls for WebContent: - `Client::did_output_js_console_message(index)`: Notifies the client that a new console message was logged. - `Server::js_console_request_messages(start_index)`: Ask the server for console messages starting at the given index. - `Client::did_get_js_console_messages(start_index, types, messages)`: Send the client the messages they requested. This mechanism will replace the current `Client::did_js_console_output()` call in the next few commits. This will allow us to display messages in the console that happened before the console was opened.
2021-09-04 11:14:25 +01:00
void OutOfProcessWebView::js_console_request_messages(i32 start_index)
{
client().async_js_console_request_messages(start_index);
}
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 OutOfProcessWebView::dump_layout_tree()
LibWeb+WebContent: Port DumpLayoutTree to OutOfProcessWebView This required adding a simple OOPWV::dump_layout_tree() API that synchronously requests a dump of the layout tree from the WebContent process.
2021-09-08 00:55:35 +02:00
{
return client().dump_layout_tree();
}
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
OrderedHashMap<DeprecatedString, DeprecatedString> OutOfProcessWebView::get_local_storage_entries()
Browser+LibWeb+WebContent: Add ability to inspect local storage The storage inspector now has a new tab for local storage. The next step would be to persist local storage and receive real-time notifications for changes to update the table view.
2022-04-02 00:14:04 +03:00
{
return client().get_local_storage_entries();
}
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
OrderedHashMap<DeprecatedString, DeprecatedString> OutOfProcessWebView::get_session_storage_entries()
Browser+LibWeb+WebContent: Add ability to inspect session storage
2022-05-07 22:45:43 +02:00
{
return client().get_session_storage_entries();
}
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 OutOfProcessWebView::set_content_filters(Vector<DeprecatedString> filters)
LibWeb+Browser: Make ad blocking work in the multi-process world We now send the list of content filters over to new WebContent processes after creating an OutOfProcessWebView. :^)
2021-09-27 11:39:17 +02:00
{
client().async_set_content_filters(filters);
}
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 OutOfProcessWebView::set_proxy_mappings(Vector<DeprecatedString> proxies, HashMap<DeprecatedString, size_t> mappings)
Browser+LibWeb+WebContent: Implement per-URL-pattern proxies ...at least for SOCKS5.
2022-04-08 01:46:47 +04:30
{
client().async_set_proxy_mappings(move(proxies), move(mappings));
}
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 OutOfProcessWebView::connect_to_webdriver(DeprecatedString const& webdriver_ipc_path)
LibWeb+WebContent: Add plumbing for 'webdriver-active flag'
2022-10-12 23:49:23 +02:00
{
Browser+LibWebView+WebDriver: Connect WebDriver to WebContent First, this moves the WebDriver socket to the /tmp/websocket/ directory, as WebDriver now creates multiple sockets per session. Those sockets are now created with Core::LocalServer rather than manually setting up the listening sockets (this was an existing FIXME which resolved some issues I was hitting with creating a second listening socket). WebDriver passes both socket paths to Browser via command line. Browser continues to connect itself via one socket path, then forwards the other socket path to the WebContent process created by the OOPWV. WebContent then connects to WebDriver over this path. WebContent will temporarily set the navigator.webdriver flag to true after connecting to WebDriver. This will soon be moved to its own IPC to be sent by WebDriver.
2022-11-08 10:18:11 -05:00
client().async_connect_to_webdriver(webdriver_ipc_path);
LibWeb+WebContent: Add plumbing for 'webdriver-active flag'
2022-10-12 23:49:23 +02:00
}
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
void OutOfProcessWebView::set_window_position(Gfx::IntPoint 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
{
client().async_set_window_position(position);
}
Meta+Userland: Pass Gfx::IntSize by value Just two ints like Gfx::IntPoint.
2022-12-06 21:35:32 +00:00
void OutOfProcessWebView::set_window_size(Gfx::IntSize 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
{
client().async_set_window_size(size);
}
Browser+LibWebView: Add a Tab hook to take a screenshot
2022-11-02 12:58:22 -04:00
Gfx::ShareableBitmap OutOfProcessWebView::take_screenshot() const
{
if (auto* bitmap = m_client_state.has_usable_bitmap ? m_client_state.front_bitmap.bitmap.ptr() : m_backup_bitmap.ptr())
return bitmap->to_shareable_bitmap();
return {};
}
LibWebView+WebContent: Add an IPC to take a full document screenshot
2022-11-05 00:09:41 -04:00
Gfx::ShareableBitmap OutOfProcessWebView::take_document_screenshot()
{
return client().take_document_screenshot();
}
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 OutOfProcessWebView::focusin_event(GUI::FocusEvent&)
{
client().async_set_has_focus(true);
}
void OutOfProcessWebView::focusout_event(GUI::FocusEvent&)
{
client().async_set_has_focus(false);
}
Browser+LibWebView+WebContent: Add IPC to re[store,size,position] window Requests to restore, resize, and reposition Browser windows will be coming from the WebContent process rather than the WebDriver process. Add hooks to propagate these requests back up to the Browser. The spec notes "The specification does not guarantee that the resulting window size will exactly match that which was requested", so these new methods return the actual new size/position.
2022-11-09 09:51:39 -05:00
void OutOfProcessWebView::set_system_visibility_state(bool visible)
{
client().async_set_system_visibility_state(visible);
}
LibWeb+WebContent+Browser: Plumb visibility state from GUI to web pages OOPWV now reacts to show/hide events and informs LibWeb about the state change. This makes visibilitychange events fire when switching tabs. :^)
2022-09-19 20:50:33 +02:00
void OutOfProcessWebView::show_event(GUI::ShowEvent&)
{
Browser+LibWebView+WebContent: Add IPC to re[store,size,position] window Requests to restore, resize, and reposition Browser windows will be coming from the WebContent process rather than the WebDriver process. Add hooks to propagate these requests back up to the Browser. The spec notes "The specification does not guarantee that the resulting window size will exactly match that which was requested", so these new methods return the actual new size/position.
2022-11-09 09:51:39 -05:00
set_system_visibility_state(true);
LibWeb+WebContent+Browser: Plumb visibility state from GUI to web pages OOPWV now reacts to show/hide events and informs LibWeb about the state change. This makes visibilitychange events fire when switching tabs. :^)
2022-09-19 20:50:33 +02:00
}
void OutOfProcessWebView::hide_event(GUI::HideEvent&)
{
Browser+LibWebView+WebContent: Add IPC to re[store,size,position] window Requests to restore, resize, and reposition Browser windows will be coming from the WebContent process rather than the WebDriver process. Add hooks to propagate these requests back up to the Browser. The spec notes "The specification does not guarantee that the resulting window size will exactly match that which was requested", so these new methods return the actual new size/position.
2022-11-09 09:51:39 -05:00
set_system_visibility_state(false);
LibWeb+WebContent+Browser: Plumb visibility state from GUI to web pages OOPWV now reacts to show/hide events and informs LibWeb about the state change. This makes visibilitychange events fire when switching tabs. :^)
2022-09-19 20:50:33 +02:00
}
LibWebView+WebContent: Propagate unconsumed input events out of OOPWV Since 9e2bd9d261a8c0c1b5eeafde95ca310efc667204, the OOPWV has been consuming all mouse and keyboard events, preventing action shortcuts from working. So let's fix that. :^) OOPWV now queues up input events, sending them one at a time to the WebContent process and waiting for the new `did_finish_handling_input_event(bool event_was_accepted) =|` IPC call before sending the next one. If the event was not accepted, OOPWV imitates the usual event bubbling: first passing the event to its superclass, then to its parent widget, and finally propagating to any Action shortcuts. With this, shortcuts like Ctrl+I to open Browser's JS console work again, except when a contenteditable field is selected. That's a whole separate stack of yaks. Co-authored-by: Zaggy1024 <zaggy1024@gmail.com>
2022-11-21 16:07:47 +00:00
void OutOfProcessWebView::enqueue_input_event(InputEvent const& event)
{
m_pending_input_events.enqueue(event);
process_next_input_event();
}
void OutOfProcessWebView::process_next_input_event()
{
if (m_pending_input_events.is_empty())
return;
if (m_is_awaiting_response_for_input_event)
return;
m_is_awaiting_response_for_input_event = true;
// Send the next event over to the web content to be handled by JS.
// We'll later get a message to say whether JS prevented the default event behavior,
// at which point we either discard or handle that event, then try and process the next one.
auto event = m_pending_input_events.head();
event.visit(
[this](GUI::KeyEvent const& event) {
switch (event.type()) {
case GUI::Event::Type::KeyDown:
client().async_key_down(event.key(), event.modifiers(), event.code_point());
break;
case GUI::Event::Type::KeyUp:
client().async_key_up(event.key(), event.modifiers(), event.code_point());
break;
default:
dbgln("Unrecognized key event type in OOPWV input event queue: {}", event.type());
VERIFY_NOT_REACHED();
}
},
[this](GUI::MouseEvent const& event) {
switch (event.type()) {
case GUI::Event::Type::MouseDown:
client().async_mouse_down(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers());
break;
case GUI::Event::Type::MouseUp:
client().async_mouse_up(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers());
break;
case GUI::Event::Type::MouseMove:
client().async_mouse_move(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers());
break;
case GUI::Event::Type::MouseWheel:
client().async_mouse_wheel(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers(), event.wheel_delta_x(), event.wheel_delta_y());
break;
case GUI::Event::Type::MouseDoubleClick:
client().async_doubleclick(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers());
break;
default:
dbgln("Unrecognized mouse event type in OOPWV input event queue: {}", event.type());
VERIFY_NOT_REACHED();
}
});
}
void OutOfProcessWebView::notify_server_did_finish_handling_input_event(bool event_was_accepted)
{
VERIFY(m_is_awaiting_response_for_input_event);
auto event = m_pending_input_events.dequeue();
m_is_awaiting_response_for_input_event = false;
if (!event_was_accepted) {
// Here we handle events that were not consumed or cancelled by web content.
// That is, we manually implement the steps that would have happened if the original
// OutOfProcessWebView::foo_event() had called event.ignore().
//
// The first step is to give our superclass a chance to handle the event.
//
// Then, if it does not, we dispatch the event to our parent widget, but limited so
// that it will never bubble up to the Window. (Otherwise, it would then dispatch the
// event to us since we are the focused widget, and it would go round indefinitely.)
//
// Finally, any unhandled KeyDown events are propagated to trigger any Actions.
event.visit(
[this](GUI::KeyEvent& event) {
switch (event.type()) {
case GUI::Event::Type::KeyDown:
Super::keydown_event(event);
break;
case GUI::Event::Type::KeyUp:
Super::keyup_event(event);
break;
default:
dbgln("Unhandled key event type in OOPWV input event queue: {}", event.type());
VERIFY_NOT_REACHED();
}
if (!event.is_accepted()) {
parent_widget()->dispatch_event(event, window());
// NOTE: If other events can ever trigger shortcuts, propagate those here.
if (!event.is_accepted() && event.type() == GUI::Event::Type::KeyDown)
window()->propagate_shortcuts_up_to_application(event, this);
}
},
[this](GUI::MouseEvent& event) {
switch (event.type()) {
case GUI::Event::Type::MouseDown:
Super::mousedown_event(event);
break;
case GUI::Event::Type::MouseUp:
Super::mouseup_event(event);
break;
case GUI::Event::Type::MouseMove:
Super::mousemove_event(event);
break;
case GUI::Event::Type::MouseWheel:
Super::mousewheel_event(event);
break;
case GUI::Event::Type::MouseDoubleClick:
Super::doubleclick_event(event);
break;
default:
dbgln("Unhandled mouse event type in OOPWV input event queue: {}", event.type());
VERIFY_NOT_REACHED();
}
if (!event.is_accepted())
parent_widget()->dispatch_event(event, window());
// FIXME: Propagate event for mouse-button shortcuts once that is implemented.
});
}
process_next_input_event();
}
LibWebView+WebContent: Expose the Accessibility Tree to Other Processes This patch also stubs out notify_server_did_get_accessiblity_tree in ladybird since ViewImplementation now has it. However, this feature is still immature, so just stubbing out in ladybird for now. Once we have more robust support in Serenity (namely ARIA properties/state and accessible names and descriptions) we can port this functionality over.
2022-12-07 19:30:37 -06:00
void OutOfProcessWebView::notify_server_did_get_accessibility_tree(DeprecatedString const& accessibility_tree)
{
if (on_get_accessibility_tree)
on_get_accessibility_tree(accessibility_tree);
}
LibWebView: Add OOPWV "content scales to viewport" hint By setting this hint, you indicate to OOPWV that the content inside will scale itself to the viewport size. In such situations, it's fine for OOPWV to reuse a scaled version of an outdated backing store while the view is being resized.
2023-01-09 18:55:22 +01:00
void OutOfProcessWebView::set_content_scales_to_viewport(bool b)
{
m_content_scales_to_viewport = b;
}
LibWeb: Move OutOfProcessWebView into the Web namespace
2020-08-24 15:33:18 +04:30
}
Reference in a new issue Copy permalink