LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-09-21 02:08:12 +03:00
Code Issues Packages Projects Releases Wiki Activity
024fd9b957
ladybird/Userland/Libraries/LibWeb/OutOfProcessWebView.h

126 lines
5.8 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 18:31:42 +03:00
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
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 22:18:16 +03:00
#include <AK/URL.h>
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-05 00:19:32 +03:00
#include <LibGUI/ScrollableWidget.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 18:31:42 +03:00
#include <LibGUI/Widget.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 22:18:16 +03:00
#include <LibWeb/WebViewHooks.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 18:31:42 +03:00
LibWeb: Move OutOfProcessWebView into the Web namespace
2020-08-24 14:03:18 +03:00
namespace Web {
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 18:31:42 +03:00
class WebContentClient;
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 17:20:47 +03:00
class OutOfProcessWebView final
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 22:18:16 +03:00
: public GUI::ScrollableWidget
, public Web::WebViewHooks {
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 17:20:47 +03: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 18:31:42 +03:00
public:
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 17:20:47 +03: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 18:31:42 +03: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 22:46:37 +03:00
URL url() const { return m_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 18:31:42 +03:00
void load(const URL&);
LibWeb: Add OutOfProcessWebView::load_html()
2020-10-08 23:11:01 +03:00
void load_html(const StringView&, const URL&);
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 23:58:00 +03:00
void load_empty_document();
LibWeb: Add OutOfProcessWebView::load_html()
2020-10-08 23:11:01 +03:00
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 11:06:25 +03:00
void debug_request(const String& request, const String& argument = {});
LibWeb: Added get source functionality and hook event
2021-02-23 15:17:23 +03:00
void get_source();
LibWeb: Add in all of the plumbing required to use the JS console over IPC
2021-02-28 06:47:14 +03:00
void js_console_initialize();
void js_console_input(const String& js_source);
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 11:06:25 +03: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-05 00:19:32 +03:00
void notify_server_did_layout(Badge<WebContentClient>, const Gfx::IntSize& content_size);
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-17 01:15:32 +03:00
void notify_server_did_paint(Badge<WebContentClient>, i32 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 19:00:18 +03:00
void notify_server_did_invalidate_content_rect(Badge<WebContentClient>, const Gfx::IntRect&);
WebContent: Notify client when web content selection changes The WebContentView widgets reacts to this by requesting a repaint.
2020-07-04 21:57:57 +03:00
void notify_server_did_change_selection(Badge<WebContentClient>);
LibWeb: Support setting the cursor in OutOfProcessWebView
2021-02-28 00:12:12 +03:00
void notify_server_did_request_cursor_change(Badge<WebContentClient>, Gfx::StandardCursor cursor);
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-05 00:40:17 +03:00
void notify_server_did_change_title(Badge<WebContentClient>, const String&);
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 00:39:07 +03:00
void notify_server_did_request_scroll(Badge<WebContentClient>, int);
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 16:43:43 +03:00
void notify_server_did_request_scroll_into_view(Badge<WebContentClient>, const Gfx::IntRect&);
LibWeb+WebContent: Support displaying tooltips in OOPWV
2021-03-30 19:10:06 +03:00
void notify_server_did_enter_tooltip_area(Badge<WebContentClient>, const Gfx::IntPoint&, const String&);
void notify_server_did_leave_tooltip_area(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 17:59:20 +03:00
void notify_server_did_hover_link(Badge<WebContentClient>, const URL&);
void notify_server_did_unhover_link(Badge<WebContentClient>);
WebContent: Plumb link clicks to the WebContentView :^) You can now react to links being clicked via the on_link_click hook.
2020-07-06 21:01:46 +03:00
void notify_server_did_click_link(Badge<WebContentClient>, const URL&, const String& target, unsigned modifiers);
void notify_server_did_middle_click_link(Badge<WebContentClient>, const URL&, const String& target, unsigned modifiers);
LibWeb: Make the WebContentView::on_load_start hook actually work :^)
2020-07-06 22:58:16 +03:00
void notify_server_did_start_loading(Badge<WebContentClient>, const 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 23:44:42 +03:00
void notify_server_did_finish_loading(Badge<WebContentClient>, const URL&);
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 13:24:29 +03:00
void notify_server_did_request_context_menu(Badge<WebContentClient>, const Gfx::IntPoint&);
void notify_server_did_request_link_context_menu(Badge<WebContentClient>, const Gfx::IntPoint&, const URL&, const String& target, unsigned modifiers);
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 17:49:25 +03:00
void notify_server_did_request_image_context_menu(Badge<WebContentClient>, const Gfx::IntPoint&, const URL&, const String& target, unsigned modifiers, const Gfx::ShareableBitmap&);
LibWeb: Support window.alert() in multi-process context Alerts are now delegated to the embedding GUI process.
2020-09-12 12:56:13 +03:00
void notify_server_did_request_alert(Badge<WebContentClient>, const String& message);
LibWeb+WebContent: Support window.confirm() in OOPWV
2021-02-10 10:48:28 +03:00
bool notify_server_did_request_confirm(Badge<WebContentClient>, const String& message);
LibWeb: Implement Window.prompt()
2021-02-20 14:05:18 +03:00
String notify_server_did_request_prompt(Badge<WebContentClient>, const String& message, const String& default_);
LibWeb: Added get source functionality and hook event
2021-02-23 15:17:23 +03:00
void notify_server_did_get_source(const URL& url, const String& source);
LibWeb: Add in all of the plumbing required to use the JS console over IPC
2021-02-28 06:47:14 +03:00
void notify_server_did_js_console_output(const String& method, const String& line);
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 17:41:25 +03:00
void notify_server_did_change_favicon(const Gfx::Bitmap& favicon);
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-14 00:30:41 +03:00
String notify_server_did_request_cookie(Badge<WebContentClient>, const URL& url, Cookie::Source source);
Browser+LibWeb+WebContent: Parse cookies in the OOP tab To protect the main Browser process against nefarious cookies, parse the cookies out-of-process and then send the parsed result over IPC to the main process. This way, if the cookie parser blows up, only that tab will be affected.
2021-04-15 17:36:20 +03:00
void notify_server_did_set_cookie(Badge<WebContentClient>, const URL& url, const Cookie::ParsedCookie& cookie, Cookie::Source source);
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 18:31:42 +03:00
private:
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 17:20:47 +03:00
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 18:31:42 +03: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-05 00:19:32 +03: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 18:31:42 +03: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 19:05:08 +03: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 21:45:41 +03:00
virtual void mousewheel_event(GUI::MouseEvent&) override;
LibWeb: Send key events to the WebContent process This makes contenteditable work in multi-process mode. :^)
2020-08-03 20:58:59 +03:00
virtual void keydown_event(GUI::KeyEvent&) override;
LibWeb: Handle theme change event in OutOfProcessWebView
2020-10-09 00:13:54 +03:00
virtual void theme_change_event(GUI::ThemeChangeEvent&) override;
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 01:12:37 +03:00
virtual void screen_rect_change_event(GUI::ScreenRectChangeEvent&) 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 18:31:42 +03: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-05 00:19:32 +03:00
// ^ScrollableWidget
virtual void did_scroll() override;
WebContent: Notify client when web content selection changes The WebContentView widgets reacts to this by requesting a repaint.
2020-07-04 21:57:57 +03:00
void request_repaint();
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 20:20:40 +03:00
void handle_resize();
WebContent: Notify client when web content selection changes The WebContentView widgets reacts to this by requesting a repaint.
2020-07-04 21:57:57 +03: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 20:20:40 +03:00
void 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 18:31:42 +03:00
WebContentClient& 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 13:07:40 +03:00
void handle_web_content_process_crash();
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 22:46:37 +03:00
URL 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 20:20:40 +03:00
struct ClientState {
RefPtr<WebContentClient> client;
RefPtr<Gfx::Bitmap> front_bitmap;
RefPtr<Gfx::Bitmap> back_bitmap;
i32 front_bitmap_id { -1 };
i32 back_bitmap_id { -1 };
i32 next_bitmap_id { 0 };
bool has_usable_bitmap { false };
} m_client_state;
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-10 00:07:36 +03:00
RefPtr<Gfx::Bitmap> m_backup_bitmap;
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 18:31:42 +03:00
};
LibWeb: Move OutOfProcessWebView into the Web namespace
2020-08-24 14:03:18 +03:00
}
Reference in New Issue Copy Permalink