Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-03 23:00:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWebView/OutOfProcessWebView.h

119 lines
5.4 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
/*
LibWeb+Browser: Remove Web::WebViewHooks class This was a mixin class that allowed sharing a set of hooks between InProcessWebView and OutOfProcessWebView. Now that there is only OOPWV, we don't need the mixin.
2022-04-06 15:15:07 +02:00
* Copyright (c) 2020-2022, Andreas Kling <kling@serenityos.org>
LibWebView+WebContent: Propagate unconsumed input events out of OOPWV Since 9e2bd9d261a8c0c1b5eeafde95ca310efc667204, the OOPWV has been consuming all mouse and keyboard events, preventing action shortcuts from working. So let's fix that. :^) OOPWV now queues up input events, sending them one at a time to the WebContent process and waiting for the new `did_finish_handling_input_event(bool event_was_accepted) =|` IPC call before sending the next one. If the event was not accepted, OOPWV imitates the usual event bubbling: first passing the event to its superclass, then to its parent widget, and finally propagating to any Action shortcuts. With this, shortcuts like Ctrl+I to open Browser's JS console work again, except when a contenteditable field is selected. That's a whole separate stack of yaks. Co-authored-by: Zaggy1024 <zaggy1024@gmail.com>
2022-11-21 16:07:47 +00:00
* Copyright (c) 2022, Sam Atkins <atkinssj@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
*/
#pragma once
LibWebView+WebContent: Propagate unconsumed input events out of OOPWV Since 9e2bd9d261a8c0c1b5eeafde95ca310efc667204, the OOPWV has been consuming all mouse and keyboard events, preventing action shortcuts from working. So let's fix that. :^) OOPWV now queues up input events, sending them one at a time to the WebContent process and waiting for the new `did_finish_handling_input_event(bool event_was_accepted) =|` IPC call before sending the next one. If the event was not accepted, OOPWV imitates the usual event bubbling: first passing the event to its superclass, then to its parent widget, and finally propagating to any Action shortcuts. With this, shortcuts like Ctrl+I to open Browser's JS console work again, except when a contenteditable field is selected. That's a whole separate stack of yaks. Co-authored-by: Zaggy1024 <zaggy1024@gmail.com>
2022-11-21 16:07:47 +00:00
#include <AK/Queue.h>
LibWeb: Add a shared WebViewHooks base class for both web view widgets This will make it easier for Browser to share code between both views.
2020-07-06 21:18:16 +02:00
#include <AK/URL.h>
LibGUI: Rename ScrollableWidget => AbstractScrollableWidget
2021-05-03 20:31:58 +02:00
#include <LibGUI/AbstractScrollableWidget.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/Widget.h>
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
#include <LibWeb/CSS/Selector.h>
WebContent+Everywhere: Add an option to not activate new tabs over IPC WebDriver, for example, will want to create new tabs without activating them.
2023-03-20 18:39:20 -04:00
#include <LibWeb/HTML/ActivateTab.h>
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
#include <LibWeb/Page/Page.h>
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
#include <LibWebView/ViewImplementation.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
Browser+LibWebView: Add WebDriver IPC plumbing for executing scripts
2022-11-02 18:08:48 +00:00
namespace Messages::WebContentServer {
class WebdriverExecuteScriptResponse;
}
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
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
class WebContentClient;
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
class OutOfProcessWebView final
: public GUI::AbstractScrollableWidget
, public ViewImplementation {
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
C_OBJECT(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
LibWebView: Define the OOPWV's superclass in one place This lets us change it later without having to remember to update a bunch of uses. (More are coming in the next commit.)
2022-11-21 15:54:18 +00:00
using Super = GUI::AbstractScrollableWidget;
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
public:
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
virtual ~OutOfProcessWebView() override;
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
DeprecatedString dump_layout_tree();
LibWeb+WebContent: Port DumpLayoutTree to OutOfProcessWebView This required adding a simple OOPWV::dump_layout_tree() API that synchronously requests a dump of the layout tree from the WebContent process.
2021-09-08 00:55:35 +02:00
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
OrderedHashMap<DeprecatedString, DeprecatedString> get_local_storage_entries();
OrderedHashMap<DeprecatedString, DeprecatedString> get_session_storage_entries();
Browser+LibWeb+WebContent: Add ability to inspect local storage The storage inspector now has a new tab for local storage. The next step would be to persist local storage and receive real-time notifications for changes to update the table view.
2022-04-02 00:14:04 +03:00
Browser+Ladybird+LibWeb: Port content filters to String
2023-04-21 07:54:56 -04:00
void set_content_filters(Vector<String>);
LibWeb+LibWebView+WebContent: Add APIs to manage an autoplay allowlist The spec defines a Permissions Policy to control some browser behaviors on a per-origin basis. Management of these permissions live in their own spec: https://w3c.github.io/webappsec-permissions-policy/ This implements a somewhat ad-hoc Permissions Policy for autoplaying media elements. We will need to implement the entire policy spec for this to be more general.
2023-04-17 13:21:19 -04:00
void set_autoplay_allowed_on_all_websites();
void set_autoplay_allowlist(Vector<String>);
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
void set_proxy_mappings(Vector<DeprecatedString> proxies, HashMap<DeprecatedString, size_t> mappings);
void connect_to_webdriver(DeprecatedString const& webdriver_ipc_path);
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
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
void set_window_position(Gfx::IntPoint);
Meta+Userland: Pass Gfx::IntSize by value Just two ints like Gfx::IntPoint.
2022-12-06 21:35:32 +00:00
void set_window_size(Gfx::IntSize);
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
Browser+LibWebView+WebContent: Add IPC to re[store,size,position] window Requests to restore, resize, and reposition Browser windows will be coming from the WebContent process rather than the WebDriver process. Add hooks to propagate these requests back up to the Browser. The spec notes "The specification does not guarantee that the resulting window size will exactly match that which was requested", so these new methods return the actual new size/position.
2022-11-09 09:51:39 -05:00
void set_system_visibility_state(bool visible);
LibWebView: Add OOPWV "content scales to viewport" hint By setting this hint, you indicate to OOPWV that the content inside will scale itself to the viewport size. In such situations, it's fine for OOPWV to reuse a scaled version of an outdated backing store while the view is being resized.
2023-01-09 18:55:22 +01:00
// This is a hint that tells OOPWV that the content will scale to the viewport size.
// In practice, this means that OOPWV may render scaled stale versions of the content while resizing.
void set_content_scales_to_viewport(bool);
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
private:
Ladybird+LibWebView: Respawn with same JS interpreter after crash WebView::ViewImplementation now remembers which JS interpreter it started with, and uses the same setting if the WebContent process crashes and we have to spawn a new one.
2023-07-22 12:41:25 +02:00
explicit OutOfProcessWebView(UseJavaScriptBytecode = UseJavaScriptBytecode::No);
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
WebContent: 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
// ^Widget
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
virtual void paint_event(GUI::PaintEvent&) override;
virtual void resize_event(GUI::ResizeEvent&) override;
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
virtual void mousedown_event(GUI::MouseEvent&) override;
virtual void mouseup_event(GUI::MouseEvent&) override;
virtual void mousemove_event(GUI::MouseEvent&) override;
LibWeb: Plumb wheel events from widget layer to EventHandler
2021-02-22 19:45:41 +01:00
virtual void mousewheel_event(GUI::MouseEvent&) override;
LibWeb+LibWebView+WebContent: Get doubleclick events from LibGUI
2022-06-14 19:38:32 +02:00
virtual void doubleclick_event(GUI::MouseEvent&) override;
LibWeb: Send key events to the WebContent process This makes contenteditable work in multi-process mode. :^)
2020-08-03 19:58:59 +02:00
virtual void keydown_event(GUI::KeyEvent&) override;
LibWeb: Fire "keyup" events as well :^) This was easy, now that we have KeyboardEvent.
2021-09-28 15:39:35 +02:00
virtual void keyup_event(GUI::KeyEvent&) override;
LibWeb: Handle theme change event in OutOfProcessWebView
2020-10-08 22:13:54 +01:00
virtual void theme_change_event(GUI::ThemeChangeEvent&) override;
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
virtual void screen_rects_change_event(GUI::ScreenRectsChangeEvent&) override;
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
virtual void focusin_event(GUI::FocusEvent&) override;
virtual void focusout_event(GUI::FocusEvent&) override;
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
virtual void show_event(GUI::ShowEvent&) override;
virtual void hide_event(GUI::HideEvent&) override;
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
LibGUI: Rename ScrollableWidget => AbstractScrollableWidget
2021-05-03 20:31:58 +02:00
// ^AbstractScrollableWidget
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
virtual void did_scroll() override;
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
// ^WebView::ViewImplementation
Ladybird+LibWebView: Respawn with same JS interpreter after crash WebView::ViewImplementation now remembers which JS interpreter it started with, and uses the same setting if the WebContent process crashes and we have to spawn a new one.
2023-07-22 12:41:25 +02:00
virtual void create_client(EnableCallgrindProfiling = EnableCallgrindProfiling::No) override;
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 19:49:49 +00:00
virtual void update_zoom() override;
Meta+Userland: Pass Gfx::IntSize by value Just two ints like Gfx::IntPoint.
2022-12-06 21:35:32 +00:00
virtual void notify_server_did_layout(Badge<WebContentClient>, Gfx::IntSize content_size) override;
Ladybird+LibWebView: Remember the size of the last paint This will allow us to change the size of the backing store bitmap without conflating the size of the bitmap and the size of the paint.
2023-05-14 18:53:29 +02:00
virtual void notify_server_did_paint(Badge<WebContentClient>, i32 bitmap_id, Gfx::IntSize) override;
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
virtual void notify_server_did_invalidate_content_rect(Badge<WebContentClient>, Gfx::IntRect const&) override;
virtual void notify_server_did_change_selection(Badge<WebContentClient>) override;
virtual void notify_server_did_request_cursor_change(Badge<WebContentClient>, Gfx::StandardCursor cursor) override;
virtual void notify_server_did_request_scroll(Badge<WebContentClient>, i32, i32) override;
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
virtual void notify_server_did_request_scroll_to(Badge<WebContentClient>, Gfx::IntPoint) override;
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
virtual void notify_server_did_request_scroll_into_view(Badge<WebContentClient>, Gfx::IntRect const&) override;
Meta+Userland: Pass Gfx::IntPoint by value This is just two ints or 8 bytes or the size of the reference on x86_64 or AArch64.
2022-12-06 20:27:44 +00:00
virtual void notify_server_did_enter_tooltip_area(Badge<WebContentClient>, Gfx::IntPoint, DeprecatedString const&) override;
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
virtual void notify_server_did_leave_tooltip_area(Badge<WebContentClient>) override;
LibWeb+Ladybird+Userland: Port window.[alert,confirm,prompt] to String LibGUI and WebDriver (read: JSON) API boundaries use DeprecatedString, so that is as far as these changes can reach. The one change which isn't just a DeprecatedString to String replacement is handling the "null" prompt response. We previously checked for the null DeprecatedString, whereas we now represent this as an empty Optional<String>.
2023-03-13 17:30:51 -04:00
virtual void notify_server_did_request_alert(Badge<WebContentClient>, String const& message) override;
virtual void notify_server_did_request_confirm(Badge<WebContentClient>, String const& message) override;
virtual void notify_server_did_request_prompt(Badge<WebContentClient>, String const& message, String const& default_) override;
virtual void notify_server_did_request_set_prompt_text(Badge<WebContentClient>, String const& message) override;
LibWebView+WebContent: Begin handling open user dialogs for WebDriver The way in which dialogs should be handled is configurable by the driver capabilities object, which we don't support yet. So this implements just the default mode to dismiss the dialog and return an error if there is one open. In the OOPWV, this means we need to refer to the dialog after it has been open, so we now hold a pointer to whatever dialog is open.
2022-11-16 06:58:14 -05:00
virtual void notify_server_did_request_accept_dialog(Badge<WebContentClient>) override;
virtual void notify_server_did_request_dismiss_dialog(Badge<WebContentClient>) override;
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
virtual void notify_server_did_request_file(Badge<WebContentClient>, DeprecatedString const& path, i32) override;
LibWebView+WebContent: Propagate unconsumed input events out of OOPWV Since 9e2bd9d261a8c0c1b5eeafde95ca310efc667204, the OOPWV has been consuming all mouse and keyboard events, preventing action shortcuts from working. So let's fix that. :^) OOPWV now queues up input events, sending them one at a time to the WebContent process and waiting for the new `did_finish_handling_input_event(bool event_was_accepted) =|` IPC call before sending the next one. If the event was not accepted, OOPWV imitates the usual event bubbling: first passing the event to its superclass, then to its parent widget, and finally propagating to any Action shortcuts. With this, shortcuts like Ctrl+I to open Browser's JS console work again, except when a contenteditable field is selected. That's a whole separate stack of yaks. Co-authored-by: Zaggy1024 <zaggy1024@gmail.com>
2022-11-21 16:07:47 +00:00
virtual void notify_server_did_finish_handling_input_event(bool event_was_accepted) override;
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 14:32:17 +02:00
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 07:59:51 +02:00
virtual Gfx::IntRect viewport_rect() const override;
Browser+Ladybird+LibWebView: Virtualize computing content/widget points This will allow moving some copy-pasted functionality from web view implementations to the base LibWebView class.
2023-05-17 10:12:13 -04:00
virtual Gfx::IntPoint to_content_position(Gfx::IntPoint widget_position) const override;
virtual Gfx::IntPoint to_widget_position(Gfx::IntPoint content_position) const override;
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
LibWebView+WebContent: Propagate unconsumed input events out of OOPWV Since 9e2bd9d261a8c0c1b5eeafde95ca310efc667204, the OOPWV has been consuming all mouse and keyboard events, preventing action shortcuts from working. So let's fix that. :^) OOPWV now queues up input events, sending them one at a time to the WebContent process and waiting for the new `did_finish_handling_input_event(bool event_was_accepted) =|` IPC call before sending the next one. If the event was not accepted, OOPWV imitates the usual event bubbling: first passing the event to its superclass, then to its parent widget, and finally propagating to any Action shortcuts. With this, shortcuts like Ctrl+I to open Browser's JS console work again, except when a contenteditable field is selected. That's a whole separate stack of yaks. Co-authored-by: Zaggy1024 <zaggy1024@gmail.com>
2022-11-21 16:07:47 +00:00
using InputEvent = Variant<GUI::KeyEvent, GUI::MouseEvent>;
void enqueue_input_event(InputEvent const&);
void process_next_input_event();
LibWebView+WebContent: Begin handling open user dialogs for WebDriver The way in which dialogs should be handled is configurable by the driver capabilities object, which we don't support yet. So this implements just the default mode to dismiss the dialog and return an error if there is one open. In the OOPWV, this means we need to refer to the dialog after it has been open, so we now hold a pointer to whatever dialog is open.
2022-11-16 06:58:14 -05:00
RefPtr<GUI::Dialog> m_dialog;
LibWebView+WebContent: Propagate unconsumed input events out of OOPWV Since 9e2bd9d261a8c0c1b5eeafde95ca310efc667204, the OOPWV has been consuming all mouse and keyboard events, preventing action shortcuts from working. So let's fix that. :^) OOPWV now queues up input events, sending them one at a time to the WebContent process and waiting for the new `did_finish_handling_input_event(bool event_was_accepted) =|` IPC call before sending the next one. If the event was not accepted, OOPWV imitates the usual event bubbling: first passing the event to its superclass, then to its parent widget, and finally propagating to any Action shortcuts. With this, shortcuts like Ctrl+I to open Browser's JS console work again, except when a contenteditable field is selected. That's a whole separate stack of yaks. Co-authored-by: Zaggy1024 <zaggy1024@gmail.com>
2022-11-21 16:07:47 +00:00
bool m_is_awaiting_response_for_input_event { false };
Queue<InputEvent> m_pending_input_events;
LibWebView: Add OOPWV "content scales to viewport" hint By setting this hint, you indicate to OOPWV that the content inside will scale itself to the viewport size. In such situations, it's fine for OOPWV to reuse a scaled version of an outdated backing store while the view is being resized.
2023-01-09 18:55:22 +01:00
bool m_content_scales_to_viewport { false };
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
}
Reference in a new issue Copy permalink