LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-09-20 17:58:18 +03:00
Code Issues Packages Projects Releases Wiki Activity
ef62118c8b
ladybird/Userland/Libraries/LibWeb/OutOfProcessWebView.h

135 lines
5.7 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>
*
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 11:24:48 +03: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 18:31:42 +03:00
*/
#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>
LibGUI: Rename ScrollableWidget => AbstractScrollableWidget
2021-05-03 21:31:58 +03: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 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
LibGUI: Rename ScrollableWidget => AbstractScrollableWidget
2021-05-03 21:31:58 +03:00
: public GUI::AbstractScrollableWidget
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 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
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
AK::URL url() const { return m_url; }
void load(const AK::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
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 load_html(const StringView&, const AK::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+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 14:31:55 +03:00
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 18:35:10 +03:00
void inspect_dom_tree();
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 14:31:55 +03:00
struct DOMNodeProperties {
String specified_values_json;
String computed_values_json;
};
Optional<DOMNodeProperties> inspect_dom_node(i32 node_id);
void clear_inspected_dom_node();
LibWeb+WebContent: Add query for hovered DOM node to OOPWV This is needed for the "Inspect Element" context menu action.
2021-08-27 19:33:10 +03:00
i32 get_hovered_node_id();
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 14:31:55 +03:00
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_input(const String& js_source);
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 13:14:25 +03:00
void js_console_request_messages(i32 start_index);
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
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 17:56:42 +03:00
void run_javascript(StringView);
LibWeb: Add OOPWV IPC for retrieving selected text
2021-07-14 15:32:55 +03:00
String selected_text();
LibWeb: Add OOPWV IPC for selecting all text
2021-07-14 15:53:55 +03:00
void select_all();
LibWeb: Add OOPWV IPC for retrieving selected text
2021-07-14 15:32:55 +03:00
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 01:55:35 +03:00
String dump_layout_tree();
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 12:39:17 +03:00
void set_content_filters(Vector<String>);
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+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 13:22:44 +03:00
void notify_server_did_request_scroll(Badge<WebContentClient>, i32, i32);
LibWeb+WebContent: Add WebContentClient::did_request_scroll_to() call This call sets the absolute scroll position for the window.
2021-09-08 13:44:36 +03:00
void notify_server_did_request_scroll_to(Badge<WebContentClient>, Gfx::IntPoint const&);
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>);
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 notify_server_did_hover_link(Badge<WebContentClient>, const AK::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 17:59:20 +03:00
void notify_server_did_unhover_link(Badge<WebContentClient>);
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 notify_server_did_click_link(Badge<WebContentClient>, const AK::URL&, const String& target, unsigned modifiers);
void notify_server_did_middle_click_link(Badge<WebContentClient>, const AK::URL&, const String& target, unsigned modifiers);
void notify_server_did_start_loading(Badge<WebContentClient>, const AK::URL&);
void notify_server_did_finish_loading(Badge<WebContentClient>, const AK::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&);
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 notify_server_did_request_link_context_menu(Badge<WebContentClient>, const Gfx::IntPoint&, const AK::URL&, const String& target, unsigned modifiers);
void notify_server_did_request_image_context_menu(Badge<WebContentClient>, const Gfx::IntPoint&, const AK::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: 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 notify_server_did_get_source(const AK::URL& url, const String& 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 18:35:10 +03:00
void notify_server_did_get_dom_tree(const String& dom_tree);
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 14:47:30 +03:00
void notify_server_did_get_dom_node_properties(i32 node_id, String const& specified_style, String const& computed_style);
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 13:14:25 +03:00
void notify_server_did_output_js_console_message(i32 message_index);
void notify_server_did_get_js_console_messages(i32 start_index, Vector<String> const& message_types, Vector<String> const& messages);
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);
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
String notify_server_did_request_cookie(Badge<WebContentClient>, const AK::URL& url, Cookie::Source source);
void notify_server_did_set_cookie(Badge<WebContentClient>, const AK::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: Fire "keyup" events as well :^) This was easy, now that we have KeyboardEvent.
2021-09-28 16:39:35 +03:00
virtual void keyup_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;
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 15:16:06 +03:00
virtual void screen_rects_change_event(GUI::ScreenRectsChangeEvent&) 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
LibGUI: Rename ScrollableWidget => AbstractScrollableWidget
2021-05-03 21:31:58 +03: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-05 00:19:32 +03:00
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();
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
AK::URL m_url;
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
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 15:30:49 +03:00
struct SharedBitmap {
i32 id { -1 };
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 15:54:51 +03:00
i32 pending_paints { 0 };
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 15:30:49 +03:00
RefPtr<Gfx::Bitmap> 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 20:20:40 +03:00
struct ClientState {
RefPtr<WebContentClient> client;
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 15:30:49 +03:00
SharedBitmap front_bitmap;
SharedBitmap 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 20:20:40 +03:00
i32 next_bitmap_id { 0 };
bool has_usable_bitmap { false };
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 11:25:13 +03:00
bool got_repaint_requests_while_painting { false };
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
} 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