Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-09 09:41:02 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Services/WebContent/ConnectionFromClient.h

197 lines
8.9 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
/*
WebContent: Give paint requests a chance to happen between input events Before this patch, we had an issue where the WebContent process could get backed up with tons of pending input events (especially mouse moves) and have to work through all of those before responding to a paint request from the UI process. This could lead to a situation where we went for a very long time without seeing any visual updates. The approach I've taken here is pretty simple, we basically make a queue of all incoming input events on the WebContent process side, and then process that queue one event at a time, using a zero timer. This is basic, but it allows paint requests to come in between the input events and we do now get more frequent visual updates even during heavy pressure from input events.
2023-03-14 13:26:06 +01:00
* Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
WebContent: Add IPC for setting 'device pixels per CSS pixel'
2023-01-12 14:35:35 +00:00
* Copyright (c) 2021-2023, Linus Groh <linusg@serenityos.org>
LibWebView+WebConent: Add an IPC to get an element's enabled state
2022-11-03 13:30:11 -04:00
* Copyright (c) 2022, Tim Flynn <trflynn89@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
#include <AK/HashMap.h>
WebContent: Give paint requests a chance to happen between input events Before this patch, we had an issue where the WebContent process could get backed up with tons of pending input events (especially mouse moves) and have to work through all of those before responding to a paint request from the UI process. This could lead to a situation where we went for a very long time without seeing any visual updates. The approach I've taken here is pretty simple, we basically make a queue of all incoming input events on the WebContent process side, and then process that queue one event at a time, using a zero timer. This is basic, but it allows paint requests to come in between the input events and we do now get more frequent visual updates even during heavy pressure from input events.
2023-03-14 13:26:06 +01:00
#include <AK/Queue.h>
Userland: Rename IPC ClientConnection => ConnectionFromClient This was done with CLion's automatic rename feature and with: find . -name ClientConnection.h | rename 's/ClientConnection\.h/ConnectionFromClient.h/' find . -name ClientConnection.cpp | rename 's/ClientConnection\.cpp/ConnectionFromClient.cpp/'
2022-02-25 12:18:30 +02:00
#include <LibIPC/ConnectionFromClient.h>
WebContent: Added IPC calls for initializing JS console and sending input
2021-02-27 21:44:49 -06:00
#include <LibJS/Forward.h>
WebContent: Implement ConsoleGlobalObject which proxies to WindowObject ConsoleGlobalObject is used as the global object when running javascript from the Browser console. This lets us implement console-only functions and variables (like `$0`) without exposing them to webpage content. It passes other calls over to the usual WindowObject so any code that would have worked in the webpage will still work in the console. :^)
2021-09-03 10:16:36 +01:00
#include <LibJS/Heap/Handle.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/CSS/PreferredColorScheme.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 <LibWeb/Forward.h>
Browser+LibWeb+WebContent: Allow Browser to load local files To achieve this goal: - The Browser unveils "/tmp/portal/filesystemaccess" - Pass the page through LoadRequest => ResourceLoader - ResourceLoader requests a file to the FileSystemAccessServer via IPC - OutOfProcessWebView handles it and sends a file descriptor back to the Page.
2022-02-26 17:50:31 +01:00
#include <LibWeb/Loader/FileRequest.h>
WebContent: Use Web::Platform::Timer instead of Core::Timer This will allow WebContent to operate without a Core::EventLoop.
2022-10-05 19:33:30 +02:00
#include <LibWeb/Platform/Timer.h>
LibWebView+WebContent: Add APIs to manipulate DOM nodes This adds APIs to allow Ispector clients to: * Change a DOM text or comment node's text data. * Add, replace, or remove a DOM element's attribute. * Change a DOM element's tag.
2023-11-19 10:42:11 -05:00
#include <LibWebView/Forward.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 <WebContent/Forward.h>
LibIPC: Share most of the code between {Client,Server}Connection This patch introduces IPC::Connection which becomes the new base class of ClientConnection and ServerConnection. Most of the functionality has been hoisted up to the base class since almost all of it is useful on both sides. This gives us the ability to send synchronous messages in both directions, which is needed for the WebContent server process. Unlike other servers, WebContent does not mind blocking on a response from its client.
2020-09-12 11:44:00 +02:00
#include <WebContent/WebContentClientEndpoint.h>
WebContent: Added IPC calls for initializing JS console and sending input
2021-02-27 21:44:49 -06:00
#include <WebContent/WebContentConsoleClient.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 <WebContent/WebContentServerEndpoint.h>
namespace WebContent {
Userland: Rename IPC ClientConnection => ConnectionFromClient This was done with CLion's automatic rename feature and with: find . -name ClientConnection.h | rename 's/ClientConnection\.h/ConnectionFromClient.h/' find . -name ClientConnection.cpp | rename 's/ClientConnection\.cpp/ConnectionFromClient.cpp/'
2022-02-25 12:18:30 +02:00
class ConnectionFromClient final
: public IPC::ConnectionFromClient<WebContentClientEndpoint, WebContentServerEndpoint> {
C_OBJECT(ConnectionFromClient);
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:
Services: Use default constructors/destructors https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-23 20:58:03 -06:00
~ConnectionFromClient() override = default;
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
virtual void die() override;
LibWeb+WebContent: Plumb ability for WebContent process to hold N pages In order for same-origin NavigableContainers (iframe, frame, embed, ...) and window.open() WindowProxies to have the proper JS access to their embedder/opener, we need to host multiple top level traversables in the same WebContent process. As a first step, make WebContent::PageHost hold a HashMap of PageClient objects, each holding their own Web::Page that represents a TraversableNavigable's API surface with the UI process.
2023-11-29 09:34:38 -07:00
void initialize_js_console(Badge<PageClient>, Web::DOM::Document& document);
void destroy_js_console(Badge<PageClient>, Web::DOM::Document& document);
LibWeb+WebContent: Add new console-message IPC calls This patch introduces three new IPC calls for WebContent: - `Client::did_output_js_console_message(index)`: Notifies the client that a new console message was logged. - `Server::js_console_request_messages(start_index)`: Ask the server for console messages starting at the given index. - `Client::did_get_js_console_messages(start_index, types, messages)`: Send the client the messages they requested. This mechanism will replace the current `Client::did_js_console_output()` call in the next few commits. This will allow us to display messages in the console that happened before the console was opened.
2021-09-04 11:14:25 +01:00
LibWeb+WebContent: Do not reference-count file request objects There is currently a memory leak with these file request objects due to the callback on_file_request_finish referencing itself in its capture list. This object does not need to be reference counted or allocated on the heap. It is only ever stored in a HashMap until a response is received from the browser, and it is not shared.
2023-01-30 16:35:47 -05:00
void request_file(Web::FileRequest);
Browser+LibWeb+WebContent: Allow Browser to load local files To achieve this goal: - The Browser unveils "/tmp/portal/filesystemaccess" - Pass the page through LoadRequest => ResourceLoader - ResourceLoader requests a file to the FileSystemAccessServer via IPC - OutOfProcessWebView handles it and sends a file descriptor back to the Page.
2022-02-26 17:50:31 +01:00
WebContent: Add ConnectionFromClient::fd() accessor
2022-10-05 16:02:02 +02:00
Optional<int> fd() { return socket().fd(); }
WebContent: Provide access to ConnectionFromClient's PageHost This is needed to construct a WebDriverConnection from outside of PageHost itself in Ladybird.
2022-11-14 10:59:34 -05:00
PageHost& page_host() { return *m_page_host; }
PageHost const& page_host() const { return *m_page_host; }
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:
LibCore: Move Stream-based sockets into the `Core` namespace
2023-02-08 23:05:44 +01:00
explicit ConnectionFromClient(NonnullOwnPtr<Core::LocalSocket>);
Services: Fix visibility of Object-derivative constructors Derivatives of Core::Object should be constructed through ClassName::construct(), to avoid handling ref-counted objects with refcount zero. Fixing the visibility means that misuses like this are more difficult.
2021-10-31 23:38:04 +01:00
LibWeb+WebContent: Plumb ability for WebContent process to hold N pages In order for same-origin NavigableContainers (iframe, frame, embed, ...) and window.open() WindowProxies to have the proper JS access to their embedder/opener, we need to host multiple top level traversables in the same WebContent process. As a first step, make WebContent::PageHost hold a HashMap of PageClient objects, each holding their own Web::Page that represents a TraversableNavigable's API surface with the UI process.
2023-11-29 09:34:38 -07:00
PageClient& page(u64 index = 0);
PageClient const& page(u64 index = 0) const;
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: Add IPC call to get window handle from WebContent client
2023-03-14 07:05:57 +03:00
virtual Messages::WebContentServer::GetWindowHandleResponse get_window_handle() override;
WebContent: Add IPC call to set window handle from WebContent client
2023-03-16 17:36:36 +03:00
virtual void set_window_handle(String const& handle) override;
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
virtual void connect_to_webdriver(ByteString const& webdriver_ipc_path) override;
Userland: Change IPC funcs to use plain arguments instead of a struct Instead of having a single overloaded handle method each method gets its own unique method name now.
2021-05-02 19:54:34 +02:00
virtual void update_system_theme(Core::AnonymousBuffer const&) override;
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
virtual void update_system_fonts(ByteString const&, ByteString const&, ByteString const&) override;
LibWeb: Refactor int types in WebContentServer to DevicePixels
2023-12-14 07:17:00 +01:00
virtual void update_screen_rects(Vector<Web::DevicePixelRect> const&, u32) override;
Userland: Change IPC funcs to use plain arguments instead of a struct Instead of having a single overloaded handle method each method gets its own unique method name now.
2021-05-02 19:54:34 +02:00
virtual void load_url(URL const&) override;
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
virtual void load_html(ByteString const&) override;
LibWeb: Refactor int types in WebContentServer to DevicePixels
2023-12-14 07:17:00 +01:00
virtual void paint(Web::DevicePixelRect const&, i32) override;
virtual void set_viewport_rect(Web::DevicePixelRect const&) override;
LibWeb: Refactor WebContentServer mouse input message to DevicePixel
2023-12-15 17:46:09 +01:00
virtual void mouse_down(Web::DevicePixelPoint, Web::DevicePixelPoint, unsigned, unsigned, unsigned) override;
virtual void mouse_move(Web::DevicePixelPoint, Web::DevicePixelPoint, unsigned, unsigned, unsigned) override;
virtual void mouse_up(Web::DevicePixelPoint, Web::DevicePixelPoint, unsigned, unsigned, unsigned) override;
virtual void mouse_wheel(Web::DevicePixelPoint, Web::DevicePixelPoint, unsigned, unsigned, unsigned, Web::DevicePixels, Web::DevicePixels) override;
virtual void doubleclick(Web::DevicePixelPoint, Web::DevicePixelPoint, unsigned, unsigned, unsigned) override;
Userland: Change IPC funcs to use plain arguments instead of a struct Instead of having a single overloaded handle method each method gets its own unique method name now.
2021-05-02 19:54:34 +02:00
virtual void key_down(i32, unsigned, u32) 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 key_up(i32, unsigned, u32) override;
Userland: Change IPC funcs to use plain arguments instead of a struct Instead of having a single overloaded handle method each method gets its own unique method name now.
2021-05-02 19:54:34 +02:00
virtual void add_backing_store(i32, Gfx::ShareableBitmap const&) override;
virtual void remove_backing_store(i32) override;
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
virtual void debug_request(ByteString const&, ByteString const&) override;
Userland: Change IPC funcs to use plain arguments instead of a struct Instead of having a single overloaded handle method each method gets its own unique method name now.
2021-05-02 19:54:34 +02:00
virtual void get_source() override;
LibWeb+WebContent: Add IPC flow for Inspect DOM Tree Add `inspect_dom_tree` to WebContentServer and 'did_get_dom_tree' to WebContentClient. These two async methods form a request & response for requesting a JSON representation of the Content's DOM tree.
2021-06-07 16:35:10 +01:00
virtual void inspect_dom_tree() override;
LibWeb: Wrap PseudoElements stored in SimpleSelector in a class No functional impact intended. This is just a more complicated way of writing what we have now. The goal of this commit is so that we are able to store the 'name' of a pseudo element for use in serializing 'unknown -webkit- pseudo-elements', see: https://www.w3.org/TR/selectors-4/#compat This is quite awkward, as in pretty much all cases just the selector type enum is enough, but we will need to cache the name for serializing these unknown selectors. I can't figure out any reason why we would need this name anywhere else in the engine, so pretty much everywhere is still just passing around this raw enum. But this change will allow us to easily store the name inside of this new struct for when it is needed for serialization, once those webkit unknown elements are supported by our engine.
2023-12-10 21:00:03 +13:00
virtual Messages::WebContentServer::InspectDomNodeResponse inspect_dom_node(i32 node_id, Optional<Web::CSS::Selector::PseudoElement::Type> const& pseudo_element) override;
LibWebView+WebContent: Expose the Accessibility Tree to Other Processes This patch also stubs out notify_server_did_get_accessiblity_tree in ladybird since ViewImplementation now has it. However, this feature is still immature, so just stubbing out in ladybird for now. Once we have more robust support in Serenity (namely ARIA properties/state and accessible names and descriptions) we can port this functionality over.
2022-12-07 19:30:37 -06:00
virtual void inspect_accessibility_tree() override;
LibWeb+WebContent: Add query for hovered DOM node to OOPWV This is needed for the "Inspect Element" context menu action.
2021-08-27 17:33:10 +01:00
virtual Messages::WebContentServer::GetHoveredNodeIdResponse get_hovered_node_id() override;
LibWebView+WebContent: Add APIs to manipulate DOM nodes This adds APIs to allow Ispector clients to: * Change a DOM text or comment node's text data. * Add, replace, or remove a DOM element's attribute. * Change a DOM element's tag.
2023-11-19 10:42:11 -05:00
virtual void set_dom_node_text(i32 node_id, String const& text) override;
virtual Messages::WebContentServer::SetDomNodeTagResponse set_dom_node_tag(i32 node_id, String const& name) override;
LibWebView+WebContent: Add a WebContent IPC to add DOM attributes
2023-12-05 16:49:47 -05:00
virtual void add_dom_node_attributes(i32 node_id, Vector<WebView::Attribute> const& attributes) override;
LibWebView+WebContent: Add APIs to manipulate DOM nodes This adds APIs to allow Ispector clients to: * Change a DOM text or comment node's text data. * Add, replace, or remove a DOM element's attribute. * Change a DOM element's tag.
2023-11-19 10:42:11 -05:00
virtual void replace_dom_node_attribute(i32 node_id, String const& name, Vector<WebView::Attribute> const& replacement_attributes) override;
LibWebView+WebContent: Add WebContent IPC to create children DOM nodes This adds IPC to create append a child <div> element or a text node to a DOM node.
2023-12-07 11:00:57 -05:00
virtual Messages::WebContentServer::CreateChildElementResponse create_child_element(i32 node_id) override;
virtual Messages::WebContentServer::CreateChildTextNodeResponse create_child_text_node(i32 node_id) override;
LibWebView+WebContent: Add a WebContent IPC to clone a DOM node
2023-12-07 11:12:43 -05:00
virtual Messages::WebContentServer::CloneDomNodeResponse clone_dom_node(i32 node_id) override;
LibWebView+WebContent: Add a WebContent IPC to remove a DOM node The FIXME added to ConnectionFromClient::remove_dom_node is copied from Web::EditEventHandler. The same behavior is observed here, with many lingering Layout::TextNodes, for example.
2023-12-05 14:59:54 -05:00
virtual void remove_dom_node(i32 node_id) override;
LibWebView+WebContent: Add a WebContent IPC to get a DOM node's HTML
2023-12-06 10:36:27 -05:00
virtual Messages::WebContentServer::GetDomNodeHtmlResponse get_dom_node_html(i32 node_id) override;
LibWebView+WebContent: Add APIs to manipulate DOM nodes This adds APIs to allow Ispector clients to: * Change a DOM text or comment node's text data. * Add, replace, or remove a DOM element's attribute. * Change a DOM element's tag.
2023-11-19 10:42:11 -05: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 00:55:35 +02:00
virtual Messages::WebContentServer::DumpLayoutTreeResponse dump_layout_tree() override;
LibWeb+headless-browser: Include paint tree in layout test output This will give us a more comprehensive look at what actually gets rendered in the end, and also allows us to catch more behavior changes.
2023-08-03 09:59:12 +02:00
virtual Messages::WebContentServer::DumpPaintTreeResponse dump_paint_tree() override;
WebContent+headless-browser: Use document.body.innerText for text tests This should be less fickle than the "select all & copy selected text" trick we were doing earlier.
2023-05-28 20:54:33 +02:00
virtual Messages::WebContentServer::DumpTextResponse dump_text() override;
Browser+Ladybird+LibWeb: Port content filters to String
2023-04-21 07:54:56 -04:00
virtual void set_content_filters(Vector<String> const&) override;
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
virtual void set_autoplay_allowed_on_all_websites() override;
virtual void set_autoplay_allowlist(Vector<String> const& allowlist) override;
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
virtual void set_proxy_mappings(Vector<ByteString> const&, HashMap<ByteString, size_t> const&) override;
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
virtual void set_preferred_color_scheme(Web::CSS::PreferredColorScheme const&) 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 set_has_focus(bool) override;
WebContent: Add plumbing for 'is scripting enabled' setting
2022-03-30 23:23:14 +01:00
virtual void set_is_scripting_enabled(bool) override;
WebContent: Add IPC for setting 'device pixels per CSS pixel'
2023-01-12 14:35:35 +00:00
virtual void set_device_pixels_per_css_pixel(float) override;
LibWeb: Refactor int types in WebContentServer to DevicePixels
2023-12-14 07:17:00 +01:00
virtual void set_window_position(Web::DevicePixelPoint) override;
virtual void set_window_size(Web::DevicePixelSize) override;
Browser+LibWeb+WebContent: Allow Browser to load local files To achieve this goal: - The Browser unveils "/tmp/portal/filesystemaccess" - Pass the page through LoadRequest => ResourceLoader - ResourceLoader requests a file to the FileSystemAccessServer via IPC - OutOfProcessWebView handles it and sends a file descriptor back to the Page.
2022-02-26 17:50:31 +01:00
virtual void handle_file_return(i32 error, Optional<IPC::File> const& file, i32 request_id) 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 set_system_visibility_state(bool visible) override;
LibWeb+WebContent: Add new console-message IPC calls This patch introduces three new IPC calls for WebContent: - `Client::did_output_js_console_message(index)`: Notifies the client that a new console message was logged. - `Server::js_console_request_messages(start_index)`: Ask the server for console messages starting at the given index. - `Client::did_get_js_console_messages(start_index, types, messages)`: Send the client the messages they requested. This mechanism will replace the current `Client::did_js_console_output()` call in the next few commits. This will allow us to display messages in the console that happened before the console was opened.
2021-09-04 11:14:25 +01:00
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
virtual void js_console_input(ByteString const&) override;
virtual void run_javascript(ByteString const&) override;
LibWeb+WebContent: Add new console-message IPC calls This patch introduces three new IPC calls for WebContent: - `Client::did_output_js_console_message(index)`: Notifies the client that a new console message was logged. - `Server::js_console_request_messages(start_index)`: Ask the server for console messages starting at the given index. - `Client::did_get_js_console_messages(start_index, types, messages)`: Send the client the messages they requested. This mechanism will replace the current `Client::did_js_console_output()` call in the next few commits. This will allow us to display messages in the console that happened before the console was opened.
2021-09-04 11:14:25 +01:00
virtual void js_console_request_messages(i32) override;
LibWebView+WebContent: Wait for dialog responses without blocking IPC Currently, the WebContent process is completely blocked while waiting for a response to a dialog request. This patch allows the IPC event loop to continue executing while only blocking the HTML event loop. This will allow other processes like WebDriver to continue to operate on the WebContent process while a dialog is open.
2022-11-15 15:49:36 -05:00
virtual void alert_closed() override;
virtual void confirm_closed(bool accepted) 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 prompt_closed(Optional<String> const& response) override;
LibWeb+LibWebView+WebContent: Add support for <input type="color"> This commit introduces 3 things: - Support for the color type in HTMLInputElement itself - A mechanism for handling non event loop blocking dialogs in Page - The associated plumbing up to ViewImplementation Frontends may add support for the color picker with the ViewImplementation.on_request_color_picker function
2023-09-04 11:32:40 +02:00
virtual void color_picker_closed(Optional<Color> const& picked_color) override;
Ladybird+LibWeb: Add basic select element support
2023-12-07 15:53:49 +01:00
virtual void select_dropdown_closed(Optional<String> const& value) override;
LibWebView+WebContent: Wait for dialog responses without blocking IPC Currently, the WebContent process is completely blocked while waiting for a response to a dialog request. This patch allows the IPC event loop to continue executing while only blocking the HTML event loop. This will allow other processes like WebDriver to continue to operate on the WebContent process while a dialog is open.
2022-11-15 15:49:36 -05:00
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 10:51:38 -04:00
virtual void toggle_media_play_state() override;
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 11:29:54 -04:00
virtual void toggle_media_mute_state() override;
Ladybird+LibWeb+WebContent: Generalize video context menus for all media The data we want to send out of the WebContent process is identical for audio and video elements. Rather than just duplicating all of this for audio, generalize the names used for this IPC for all media elements. This also encapsulates that data into a struct. This makes adding new fields to be sent much easier (such as an upcoming field for muting the element).
2023-06-16 10:51:38 -04:00
virtual void toggle_media_loop_state() override;
virtual void toggle_media_controls_state() override;
LibWeb+WebContent: Add APIs to control video playback state This allows for the browser process to control the play/pause state, whether we paint user agent controls on the video, and whether the video loops when it finishes playing.
2023-05-15 11:17:58 -04:00
WebContent+LibWebView: Add support for user style sheets
2023-08-21 15:50:31 +01:00
virtual void set_user_style(String const&) override;
LibWeb+LibWebView+WebContent: Add an Inspector IDL object to the Window This is an internal object that must be explicitly enabled by the chrome before it is added to the Window. The Inspector object will be used by a special WebView that will replace all chrome-specific inspector windows. The IDL defines methods that this WebView will need to inform the chrome of various events, such as the user clicking a DOM node.
2023-11-23 12:22:23 -05:00
virtual void enable_inspector_prototype() override;
LibWebView+WebContent: Add an IPC to take a full document screenshot
2022-11-05 00:09:41 -04:00
virtual Messages::WebContentServer::TakeDocumentScreenshotResponse take_document_screenshot() override;
LibWebView+WebContent: Add a WebContent IPC to take DOM node screenshots
2023-12-06 11:51:44 -05:00
virtual Messages::WebContentServer::TakeDomNodeScreenshotResponse take_dom_node_screenshot(i32 node_id) override;
WebContent: Add more IPC endpoints for getting Elements This patch adds `get_document_element()` and `query_selector_all()` which return Node's IDs. `get_document_element` returns the ID of the document element `query_selector_all` returns the IDs of all elements matching the selector starting at the Node associated with the start_node_id
2022-10-18 12:40:14 +02:00
LibJS+LibWebView+WebContent+Ladybird: Output GC-graph into a file Instead of displaying a massive JSON in stdout, it's more practical to save the GC-graph to a file.
2023-12-12 13:25:06 +01:00
virtual Messages::WebContentServer::DumpGcGraphResponse dump_gc_graph() override;
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
virtual Messages::WebContentServer::GetLocalStorageEntriesResponse get_local_storage_entries() override;
Browser+LibWeb+WebContent: Add ability to inspect session storage
2022-05-07 22:45:43 +02:00
virtual Messages::WebContentServer::GetSessionStorageEntriesResponse get_session_storage_entries() override;
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
LibWeb: Add OOPWV IPC for retrieving selected text
2021-07-14 08:32:55 -04:00
virtual Messages::WebContentServer::GetSelectedTextResponse get_selected_text() override;
LibWeb: Add OOPWV IPC for selecting all text
2021-07-14 08:53:55 -04:00
virtual void select_all() 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
WebContent: Coalesce pending paint events to reduce overdraw Instead of painting synchronously whenever a Paint request comes in, the WebContent process will now buffer pending paints and coalesce them and defer the actual paint using a zero-timer. This significantly reduces flickering already, without doing any double-buffering in the WebContentView widget.
2020-07-05 16:26:15 +02:00
void flush_pending_paint_requests();
LibWebView+WebContent: Propagate unconsumed input events out of OOPWV Since 9e2bd9d261a8c0c1b5eeafde95ca310efc667204, the OOPWV has been consuming all mouse and keyboard events, preventing action shortcuts from working. So let's fix that. :^) OOPWV now queues up input events, sending them one at a time to the WebContent process and waiting for the new `did_finish_handling_input_event(bool event_was_accepted) =|` IPC call before sending the next one. If the event was not accepted, OOPWV imitates the usual event bubbling: first passing the event to its superclass, then to its parent widget, and finally propagating to any Action shortcuts. With this, shortcuts like Ctrl+I to open Browser's JS console work again, except when a contenteditable field is selected. That's a whole separate stack of yaks. Co-authored-by: Zaggy1024 <zaggy1024@gmail.com>
2022-11-21 16:07:47 +00:00
void report_finished_handling_input_event(bool event_was_handled);
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
NonnullOwnPtr<PageHost> m_page_host;
WebContent: Coalesce pending paint events to reduce overdraw Instead of painting synchronously whenever a Paint request comes in, the WebContent process will now buffer pending paints and coalesce them and defer the actual paint using a zero-timer. This significantly reduces flickering already, without doing any double-buffering in the WebContentView widget.
2020-07-05 16:26:15 +02:00
struct PaintRequest {
LibWeb: Refactor int types in WebContentServer to DevicePixels
2023-12-14 07:17:00 +01:00
Web::DevicePixelRect content_rect;
WebContent: Coalesce pending paint events to reduce overdraw Instead of painting synchronously whenever a Paint request comes in, the WebContent process will now buffer pending paints and coalesce them and defer the actual paint using a zero-timer. This significantly reduces flickering already, without doing any double-buffering in the WebContentView widget.
2020-07-05 16:26:15 +02:00
NonnullRefPtr<Gfx::Bitmap> bitmap;
LibWeb+WebContent: Use anonymous files for OOPWV backing stores To support this, the GUI process and the WebContent service will now coordinate their backing store bitmaps. Each backing store can be referred to by a serial ID, and we don't need to keep resending it as a file descriptor. We should probably do something similar in WindowServer. :^)
2021-01-16 23:15:32 +01:00
i32 bitmap_id { -1 };
WebContent: Coalesce pending paint events to reduce overdraw Instead of painting synchronously whenever a Paint request comes in, the WebContent process will now buffer pending paints and coalesce them and defer the actual paint using a zero-timer. This significantly reduces flickering already, without doing any double-buffering in the WebContentView widget.
2020-07-05 16:26:15 +02:00
};
Vector<PaintRequest> m_pending_paint_requests;
WebContent: Use Web::Platform::Timer instead of Core::Timer This will allow WebContent to operate without a Core::EventLoop.
2022-10-05 19:33:30 +02:00
RefPtr<Web::Platform::Timer> m_paint_flush_timer;
LibWeb+WebContent: Use anonymous files for OOPWV backing stores To support this, the GUI process and the WebContent service will now coordinate their backing store bitmaps. Each backing store can be referred to by a serial ID, and we don't need to keep resending it as a file descriptor. We should probably do something similar in WindowServer. :^)
2021-01-16 23:15:32 +01:00
HashMap<i32, NonnullRefPtr<Gfx::Bitmap>> m_backing_stores;
WebContent: Added IPC calls for initializing JS console and sending input
2021-02-27 21:44:49 -06:00
LibWeb+WebContent: Create `WebContentConsoleClient` for every document Fixes regression introduced in b4fe118dff6c1bd839f0443f9d822ae078895814 The `WebContentConsoleClient` needs to be created not just once, but for every new document. Although the JS Console window allows communication only with the active document associated with the top-level browsing context, we still need a console client for each iframe's document to ensure their console logs are printed. In the future, we might consider adding the ability to switch which document the JS Console window communicates with. Fixes https://github.com/SerenityOS/serenity/issues/21117
2023-09-17 16:11:16 +02:00
HashMap<Web::DOM::Document*, NonnullOwnPtr<WebContentConsoleClient>> m_console_clients;
WeakPtr<WebContentConsoleClient> m_top_level_document_console_client;
WebContent: Implement ConsoleGlobalObject which proxies to WindowObject ConsoleGlobalObject is used as the global object when running javascript from the Browser console. This lets us implement console-only functions and variables (like `$0`) without exposing them to webpage content. It passes other calls over to the usual WindowObject so any code that would have worked in the webpage will still work in the console. :^)
2021-09-03 10:16:36 +01:00
JS::Handle<JS::GlobalObject> m_console_global_object;
Browser+LibWeb+WebContent: Allow Browser to load local files To achieve this goal: - The Browser unveils "/tmp/portal/filesystemaccess" - Pass the page through LoadRequest => ResourceLoader - ResourceLoader requests a file to the FileSystemAccessServer via IPC - OutOfProcessWebView handles it and sends a file descriptor back to the Page.
2022-02-26 17:50:31 +01:00
LibWeb+WebContent: Do not reference-count file request objects There is currently a memory leak with these file request objects due to the callback on_file_request_finish referencing itself in its capture list. This object does not need to be reference counted or allocated on the heap. It is only ever stored in a HashMap until a response is received from the browser, and it is not shared.
2023-01-30 16:35:47 -05:00
HashMap<int, Web::FileRequest> m_requested_files {};
Browser+LibWeb+WebContent: Allow Browser to load local files To achieve this goal: - The Browser unveils "/tmp/portal/filesystemaccess" - Pass the page through LoadRequest => ResourceLoader - ResourceLoader requests a file to the FileSystemAccessServer via IPC - OutOfProcessWebView handles it and sends a file descriptor back to the Page.
2022-02-26 17:50:31 +01:00
int last_id { 0 };
WebContent: Give paint requests a chance to happen between input events Before this patch, we had an issue where the WebContent process could get backed up with tons of pending input events (especially mouse moves) and have to work through all of those before responding to a paint request from the UI process. This could lead to a situation where we went for a very long time without seeing any visual updates. The approach I've taken here is pretty simple, we basically make a queue of all incoming input events on the WebContent process side, and then process that queue one event at a time, using a zero timer. This is basic, but it allows paint requests to come in between the input events and we do now get more frequent visual updates even during heavy pressure from input events.
2023-03-14 13:26:06 +01:00
struct QueuedMouseEvent {
enum class Type {
MouseMove,
MouseDown,
MouseUp,
MouseWheel,
DoubleClick,
};
Type type {};
LibWeb: Refactor WebContentServer mouse input message to DevicePixel
2023-12-15 17:46:09 +01:00
Web::DevicePixelPoint position {};
Web::DevicePixelPoint screen_position {};
WebContent: Give paint requests a chance to happen between input events Before this patch, we had an issue where the WebContent process could get backed up with tons of pending input events (especially mouse moves) and have to work through all of those before responding to a paint request from the UI process. This could lead to a situation where we went for a very long time without seeing any visual updates. The approach I've taken here is pretty simple, we basically make a queue of all incoming input events on the WebContent process side, and then process that queue one event at a time, using a zero timer. This is basic, but it allows paint requests to come in between the input events and we do now get more frequent visual updates even during heavy pressure from input events.
2023-03-14 13:26:06 +01:00
unsigned button {};
unsigned buttons {};
unsigned modifiers {};
LibWeb: Refactor WebContentServer mouse input message to DevicePixel
2023-12-15 17:46:09 +01:00
Web::DevicePixels wheel_delta_x {};
Web::DevicePixels wheel_delta_y {};
WebContent: Coalesce multiple sequential MouseMove events This can avoid getting into a situation where lots of MouseMove events are queued up and they all trigger relayout (or something else that takes a lot of time). To make sure that we don't get out of sync with the input events queue on the UI process side, we still send acknowledgements for coalesced MouseMoves. There's room for improvement here. My Discord friends list is now pleasantly responsive. :^)
2023-03-14 13:47:40 +01:00
size_t coalesced_event_count { 0 };
WebContent: Give paint requests a chance to happen between input events Before this patch, we had an issue where the WebContent process could get backed up with tons of pending input events (especially mouse moves) and have to work through all of those before responding to a paint request from the UI process. This could lead to a situation where we went for a very long time without seeing any visual updates. The approach I've taken here is pretty simple, we basically make a queue of all incoming input events on the WebContent process side, and then process that queue one event at a time, using a zero timer. This is basic, but it allows paint requests to come in between the input events and we do now get more frequent visual updates even during heavy pressure from input events.
2023-03-14 13:26:06 +01:00
};
struct QueuedKeyboardEvent {
enum class Type {
KeyDown,
KeyUp,
};
Type type {};
i32 key {};
unsigned int modifiers {};
u32 code_point {};
};
void enqueue_input_event(Variant<QueuedMouseEvent, QueuedKeyboardEvent>);
void process_next_input_event();
Queue<Variant<QueuedMouseEvent, QueuedKeyboardEvent>> m_input_event_queue;
RefPtr<Web::Platform::Timer> m_input_event_queue_timer;
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
};
}
Reference in a new issue Copy permalink