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

641 lines
21 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"
LibWeb: URL-encode/escape variables used in OOPWV's crash error page This fixes arbitrary HTML injections via the URL on OOPWV's crash error page - probably not a security issue, but annoying nonetheless.
2021-01-30 21:57:16 +01:00
#include <AK/String.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>
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);
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
builder.append(escape_html_entities(m_url.to_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);
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
auto escaped_url = escape_html_entities(m_url.to_string());
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);
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
load_html(builder.to_string(), m_url);
}
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: 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::load(const AK::URL& url)
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+LibWeb: Pave the way for using WebContentView in Browser This commit sets everything up, but we still always instantiate a plain Web::PageView in Browser::Tab..
2020-07-06 21:46:37 +02:00
m_url = url;
Userland: Update IPC calls to use proxies This updates all existing code to use the auto-generated client methods instead of post_message/send_sync.
2021-05-03 13:33:59 +02:00
client().async_load_url(url);
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: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
void OutOfProcessWebView::load_html(StringView html, const AK::URL& url)
LibWeb: Add OutOfProcessWebView::load_html()
2020-10-08 21:11:01 +01:00
{
m_url = url;
Userland: Update IPC calls to use proxies This updates all existing code to use the auto-generated client methods instead of post_message/send_sync.
2021-05-03 13:33:59 +02:00
client().async_load_html(html, url);
LibWeb: Add OutOfProcessWebView::load_html()
2020-10-08 21:11:01 +01:00
}
LibWeb: Add OutOfProcessWebView::load_empty_document() This is cheating a little bit as we don't set the document to a nullptr as in InProcessWebView, but the observable outcome is the same. :^)
2020-10-08 21:58:00 +01:00
void OutOfProcessWebView::load_empty_document()
{
m_url = {};
Userland: Update IPC calls to use proxies This updates all existing code to use the auto-generated client methods instead of post_message/send_sync.
2021-05-03 13:33:59 +02:00
client().async_load_html("", {});
LibWeb: Add OutOfProcessWebView::load_empty_document() This is cheating a little bit as we don't set the document to a nullptr as in InProcessWebView, but the observable outcome is the same. :^)
2020-10-08 21:58:00 +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
{
LibGUI: Rename ScrollableWidget => AbstractScrollableWidget
2021-05-03 20:31:58 +02:00
GUI::AbstractScrollableWidget::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());
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
{
LibGUI: Rename ScrollableWidget => AbstractScrollableWidget
2021-05-03 20:31:58 +02:00
GUI::AbstractScrollableWidget::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
}
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
{
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_key_down(event.key(), event.modifiers(), event.code_point());
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)
{
client().async_key_up(event.key(), event.modifiers(), event.code_point());
}
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
{
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_mouse_down(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers());
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
{
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_mouse_up(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers());
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
{
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_mouse_move(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers());
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)
{
Userland: Add horizontal mouse scroll support
2021-12-13 23:22:28 +01:00
client().async_mouse_wheel(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers(), event.wheel_delta_x(), event.wheel_delta_y());
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)
{
client().async_doubleclick(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers());
}
LibWeb: Handle theme change event in OutOfProcessWebView
2020-10-08 22:13:54 +01:00
void OutOfProcessWebView::theme_change_event(GUI::ThemeChangeEvent& event)
{
LibGUI: Rename ScrollableWidget => AbstractScrollableWidget
2021-05-03 20:31:58 +02:00
GUI::AbstractScrollableWidget::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);
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_did_layout(Badge<WebContentClient>, Gfx::IntSize const& 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);
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_did_change_title(Badge<WebContentClient>, String 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
}
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
void OutOfProcessWebView::notify_server_did_request_scroll_to(Badge<WebContentClient>, Gfx::IntPoint const& scroll_position)
{
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);
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_did_enter_tooltip_area(Badge<WebContentClient>, Gfx::IntPoint const&, String 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({});
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_did_click_link(Badge<WebContentClient>, const AK::URL& url, String 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);
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_did_middle_click_link(Badge<WebContentClient>, const AK::URL& url, String 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);
}
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_start_loading(Badge<WebContentClient>, const AK::URL& url)
LibWeb: Make the WebContentView::on_load_start hook actually work :^)
2020-07-06 21:58:16 +02:00
{
if (on_load_start)
on_load_start(url);
}
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
{
if (on_load_finish)
on_load_finish(url);
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_did_request_context_menu(Badge<WebContentClient>, Gfx::IntPoint const& 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)));
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_did_request_link_context_menu(Badge<WebContentClient>, Gfx::IntPoint const& content_position, const AK::URL& url, String 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)));
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_did_request_image_context_menu(Badge<WebContentClient>, Gfx::IntPoint const& content_position, const AK::URL& url, String 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);
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_did_request_alert(Badge<WebContentClient>, String 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
{
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
GUI::MessageBox::show(window(), message, "Alert"sv, GUI::MessageBox::Type::Information);
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
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
bool OutOfProcessWebView::notify_server_did_request_confirm(Badge<WebContentClient>, String const& message)
LibWeb+WebContent: Support window.confirm() in OOPWV
2021-02-10 08:48:28 +01:00
{
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
auto confirm_result = GUI::MessageBox::show(window(), message, "Confirm"sv, GUI::MessageBox::Type::Warning, GUI::MessageBox::InputType::OKCancel);
LibGUI+Userland: Make Dialog::ExecResult an enum class
2022-05-13 13:10:27 +01:00
return confirm_result == GUI::Dialog::ExecResult::OK;
LibWeb+WebContent: Support window.confirm() in OOPWV
2021-02-10 08:48:28 +01:00
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
String OutOfProcessWebView::notify_server_did_request_prompt(Badge<WebContentClient>, String const& message, String const& default_)
LibWeb: Implement Window.prompt()
2021-02-20 12:05:18 +01:00
{
String response { default_ };
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
if (GUI::InputBox::show(window(), response, message, "Prompt"sv) == GUI::InputBox::ExecResult::OK)
LibWeb: Implement Window.prompt()
2021-02-20 12:05:18 +01:00
return response;
return {};
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_did_get_source(const AK::URL& url, String 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);
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_did_get_dom_tree(String 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+LibWeb: Add an Element size preview widget to inspector This Adds an element size preview widget to the inspector widget in a new tab. This functions similar to chrome and firefox and shows the margin, border, padding, and content size of the selected element in the inspector. The colors for the size preview widget are taken from the chrome browser.
2022-02-27 01:38:12 +01:00
void OutOfProcessWebView::notify_server_did_get_dom_node_properties(i32 node_id, String const& specified_style, String const& computed_style, String const& custom_properties, String 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+LibWeb: Add an Element size preview widget to inspector This Adds an element size preview widget to the inspector widget in a new tab. This functions similar to chrome and firefox and shows the margin, border, padding, and content size of the selected element in the inspector. The colors for the size preview widget are taken from the chrome browser.
2022-02-27 01:38:12 +01:00
on_get_dom_node_properties(node_id, specified_style, computed_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);
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::notify_server_did_get_js_console_messages(i32 start_index, Vector<String> const& message_types, Vector<String> 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: 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
String 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
}
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+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
void OutOfProcessWebView::notify_server_did_request_file(Badge<WebContentClient>, String const& path, i32 request_id)
{
auto file = FileSystemAccessClient::Client::the().try_request_file_read_only_approved(window(), path);
if (file.is_error())
client().async_handle_file_return(file.error().code(), {}, request_id);
else
client().async_handle_file_return(0, IPC::File(file.value()->leak_fd()), request_id);
}
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
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
WebContentClient& OutOfProcessWebView::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
{
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: 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
return *m_client_state.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
}
LibWeb: Move OutOfProcessWebView into the Web namespace
2020-08-24 15:33:18 +04:30
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::debug_request(String const& request, String const& argument)
Browser+LibWeb+WebContent: Make the "Debug" menu work in multi-process This patch adds an IPC call for debugging requests. It's stringly typed and very simple, and allows us to easily implement all the features in the Browser's Debug menu.
2021-01-31 09:06:25 +01:00
{
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_debug_request(request, argument);
Browser+LibWeb+WebContent: Make the "Debug" menu work in multi-process This patch adds an IPC call for debugging requests. It's stringly typed and very simple, and allows us to easily implement all the features in the Browser's Debug menu.
2021-01-31 09:06:25 +01:00
}
LibWeb: Added get source functionality and hook event
2021-02-23 06:17:23 -06:00
void OutOfProcessWebView::get_source()
{
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_get_source();
LibWeb: Added get source functionality and hook event
2021-02-23 06:17:23 -06:00
}
LibWebView+WebContent: Add IPC to run the fragment serialization steps
2022-11-02 20:55:16 -04:00
String OutOfProcessWebView::serialize_source()
{
return client().serialize_source();
}
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
void OutOfProcessWebView::inspect_dom_tree()
{
client().async_inspect_dom_tree();
}
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
Optional<OutOfProcessWebView::DOMNodeProperties> OutOfProcessWebView::inspect_dom_node(i32 node_id, Optional<Web::CSS::Selector::PseudoElement> pseudo_element)
LibWeb+WebContent: Add inspect_dom_node() IPC call This is the IPC version of `Document::set_inspected_node()`, using a node ID. We return the inspected node's style properties as JSON, so that the DOM Inspector can immediately display them.
2021-08-27 12:31:55 +01:00
{
Browser+LibWeb+WebContent: Show style for pseudo-elements :^) This expands the InspectorWidget::Selection to include an optional PseudoElement, which is then passed over IPC to request style information for it. As noted, this has some pretty big limitations because pseudo-elements don't have DOM nodes: - Declared style has to be recalculated when it's requested. - We don't display the computed style. - We don't display custom properties.
2022-03-04 16:29:05 +00:00
auto response = client().inspect_dom_node(node_id, pseudo_element);
LibWeb+WebContent: Add inspect_dom_node() IPC call This is the IPC version of `Document::set_inspected_node()`, using a node ID. We return the inspected node's style properties as JSON, so that the DOM Inspector can immediately display them.
2021-08-27 12:31:55 +01:00
if (!response.has_style())
return {};
return DOMNodeProperties {
.specified_values_json = response.specified_style(),
Browser+LibWeb+WebContent: Add variables display to Inspector This allows us to see which custom properties apply to a given element, which previously wasn't shown.
2021-12-08 11:51:26 +00:00
.computed_values_json = response.computed_style(),
Browser+LibWeb: Add an Element size preview widget to inspector This Adds an element size preview widget to the inspector widget in a new tab. This functions similar to chrome and firefox and shows the margin, border, padding, and content size of the selected element in the inspector. The colors for the size preview widget are taken from the chrome browser.
2022-02-27 01:38:12 +01:00
.custom_properties_json = response.custom_properties(),
.node_box_sizing_json = response.node_box_sizing()
LibWeb+WebContent: Add inspect_dom_node() IPC call This is the IPC version of `Document::set_inspected_node()`, using a node ID. We return the inspected node's style properties as JSON, so that the DOM Inspector can immediately display them.
2021-08-27 12:31:55 +01:00
};
}
void OutOfProcessWebView::clear_inspected_dom_node()
{
Browser+LibWeb+WebContent: Show style for pseudo-elements :^) This expands the InspectorWidget::Selection to include an optional PseudoElement, which is then passed over IPC to request style information for it. As noted, this has some pretty big limitations because pseudo-elements don't have DOM nodes: - Declared style has to be recalculated when it's requested. - We don't display the computed style. - We don't display custom properties.
2022-03-04 16:29:05 +00:00
client().inspect_dom_node(0, {});
LibWeb+WebContent: Add inspect_dom_node() IPC call This is the IPC version of `Document::set_inspected_node()`, using a node ID. We return the inspected node's style properties as JSON, so that the DOM Inspector can immediately display them.
2021-08-27 12:31:55 +01:00
}
LibWeb+WebContent: Add query for hovered DOM node to OOPWV This is needed for the "Inspect Element" context menu action.
2021-08-27 17:33:10 +01:00
i32 OutOfProcessWebView::get_hovered_node_id()
{
return client().get_hovered_node_id();
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void OutOfProcessWebView::js_console_input(String 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);
}
LibWeb+WebContent: Add a simple API for running arbitrary JavaScript This patch adds OutOfProcessWebView::run_javascript(StringView). This can be used by the OOPWV embedder to execute arbitrary JavaScript in the top-level browsing context on the WebContent process side.
2021-08-24 16:56:42 +02:00
void OutOfProcessWebView::run_javascript(StringView js_source)
{
client().async_run_javascript(js_source);
}
LibWeb: Add OOPWV IPC for retrieving selected text
2021-07-14 08:32:55 -04:00
String OutOfProcessWebView::selected_text()
{
return client().get_selected_text();
}
LibWeb: Add OOPWV IPC for selecting all text
2021-07-14 08:53:55 -04:00
void OutOfProcessWebView::select_all()
{
client().async_select_all();
}
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
String OutOfProcessWebView::dump_layout_tree()
{
return client().dump_layout_tree();
}
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
OrderedHashMap<String, String> OutOfProcessWebView::get_local_storage_entries()
{
return client().get_local_storage_entries();
}
Browser+LibWeb+WebContent: Add ability to inspect session storage
2022-05-07 22:45:43 +02:00
OrderedHashMap<String, String> OutOfProcessWebView::get_session_storage_entries()
{
return client().get_session_storage_entries();
}
WebDriver+Friends: Add IPC and plumbing for Element-getting This extends the IPC calls `get_document_element` and `query_selector_all` to be usable by the WebDriver. For this the `WebDriverConnection` provides the same interfaces and takes care of routing the data through the Browser.
2022-10-18 12:44:21 +02:00
Optional<i32> OutOfProcessWebView::get_document_element()
{
return client().get_document_element();
}
Optional<Vector<i32>> OutOfProcessWebView::query_selector_all(i32 start_node_id, String const& selector)
{
return client().query_selector_all(start_node_id, selector);
}
LibWebView+WebConent: Add an IPC to get an element's selected state
2022-11-03 17:04:24 -04:00
bool OutOfProcessWebView::is_element_selected(i32 element_id)
{
return client().is_element_selected(element_id);
}
WebContent+Friends: Add get_element_attribute IPC and plumbing
2022-10-19 16:56:08 +02:00
Optional<String> OutOfProcessWebView::get_element_attribute(i32 element_id, String const& name)
{
return client().get_element_attribute(element_id, name);
}
WebContent+Friends: Add get_element_property IPC and plumbing
2022-10-19 20:45:25 +02:00
Optional<String> OutOfProcessWebView::get_element_property(i32 element_id, String const& name)
{
return client().get_element_property(element_id, name);
}
WebContent+Friends: Add IPC and plumbing for WebDriver endpoint To use the `GET /session/{id}/element/{id}/css/{property name}` WebDriver endpoint, two new IPC calls through the Browser are implemented: - get_active_documents_type returns the type of the active document, which is either "xml" or "html" - get_computed_value_for_element returns the computed CSS value (as String) for the given element and CSS property name
2022-10-20 12:02:47 +02:00
String OutOfProcessWebView::get_active_documents_type()
{
return client().get_active_documents_type();
}
String OutOfProcessWebView::get_computed_value_for_element(i32 element_id, String const& property_name)
{
return client().get_computed_value_for_element(element_id, property_name);
}
WebContent+Friends: Add get_element_text IPC and plumbing
2022-11-01 10:10:51 +01:00
String OutOfProcessWebView::get_element_text(i32 element_id)
{
return client().get_element_text(element_id);
}
WebContent+Friends: Add get_element_tag_name IPC and plumbing
2022-10-20 22:39:41 +02:00
String OutOfProcessWebView::get_element_tag_name(i32 element_id)
{
return client().get_element_tag_name(element_id);
}
LibWebView+WebConent: Add an IPC to get an element's absolute rect
2022-11-03 12:51:44 -04:00
Gfx::IntRect OutOfProcessWebView::get_element_rect(i32 element_id)
{
return client().get_element_rect(element_id);
}
LibWebView+WebConent: Add an IPC to get an element's enabled state
2022-11-03 13:30:11 -04:00
bool OutOfProcessWebView::is_element_enabled(i32 element_id)
{
return client().is_element_enabled(element_id);
}
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
void OutOfProcessWebView::set_content_filters(Vector<String> filters)
{
client().async_set_content_filters(filters);
}
Browser+LibWeb+WebContent: Implement per-URL-pattern proxies ...at least for SOCKS5.
2022-04-08 01:46:47 +04:30
void OutOfProcessWebView::set_proxy_mappings(Vector<String> proxies, HashMap<String, size_t> mappings)
{
client().async_set_proxy_mappings(move(proxies), move(mappings));
}
LibWeb+WebContent: Add set_preferred_color_scheme IPC call This allows the owner of a WebView to override whether to use a dark theme or not, instead of just using the system theme's IsDark property.
2021-10-26 17:00:10 +01:00
void OutOfProcessWebView::set_preferred_color_scheme(Web::CSS::PreferredColorScheme color_scheme)
{
client().async_set_preferred_color_scheme(color_scheme);
}
LibWeb+WebContent: Add plumbing for 'webdriver-active flag'
2022-10-12 23:49:23 +02:00
void OutOfProcessWebView::set_is_webdriver_active(bool is_webdriver_enabled)
{
client().async_set_is_webdriver_active(is_webdriver_enabled);
}
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
void OutOfProcessWebView::set_window_position(Gfx::IntPoint const& position)
{
client().async_set_window_position(position);
}
void OutOfProcessWebView::set_window_size(Gfx::IntSize const& size)
{
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 {};
}
Browser+LibWebView: Add WebDriver IPC plumbing for executing scripts
2022-11-02 18:08:48 +00:00
Messages::WebContentServer::WebdriverExecuteScriptResponse OutOfProcessWebView::webdriver_execute_script(String const& body, Vector<String> const& json_arguments, Optional<u64> const& timeout, bool async)
{
return client().webdriver_execute_script(body, json_arguments, timeout, async);
}
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);
}
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&)
{
client().async_set_system_visibility_state(true);
}
void OutOfProcessWebView::hide_event(GUI::HideEvent&)
{
client().async_set_system_visibility_state(false);
}
LibWeb: Move OutOfProcessWebView into the Web namespace
2020-08-24 15:33:18 +04:30
}
Reference in a new issue Copy permalink