beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-27 01:50:24 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7
ladybird/Userland/Services/WebContent/PageClient.h

218 lines
12 KiB
C
Raw Normal View History

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 16:34:38 +00:00
/*
* Copyright (c) 2020-2023, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2021-2022, Linus Groh <linusg@serenityos.org>
* Copyright (c) 2023, Andrew Kaster <akaster@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <LibGfx/Rect.h>
LibWeb: Add method for listing all style sheets on a page This will be used by the inspector, for showing style sheet contents. Identifying a specific style sheet is a bit tricky. Depending on where it came from, a style sheet may have a URL, it might be associated with a DOM element, both, or neither. This varied information is wrapped in a new StyleSheetIdentifier struct.
2024-08-23 09:42:35 +00:00
#include <LibWeb/CSS/StyleSheetIdentifier.h>
LibWeb+LibWebView+WebContent: Inform chromes when audio is played/paused Most browsers have some indicator when audio is playing in a tab, which makes it easier to find that tab and mute unwanted audio. This adds an IPC to allow the Ladybird chromes to do something similar.
2024-03-26 23:27:06 +00:00
#include <LibWeb/HTML/AudioPlayState.h>
Ladybird+LibWeb+WebContent: Parse the <input type=file> accept attribute This parses the accept attribute value for file input types and passes it along to the browser chromes.
2024-03-14 16:26:00 +00:00
#include <LibWeb/HTML/FileFilter.h>
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 16:34:38 +00:00
#include <LibWeb/Page/Page.h>
#include <LibWeb/PixelUnits.h>
LibWebView+WebContent: Move backing store allocation into WebContent In the upcoming changes, we are going to switch macOS to using an IOSurface for the backing store. This change will simplify the process of sharing an IOSurface between processes because we already have the MachPortServer running in the browser, and WebContent knows how to locate the corresponding server.
2024-06-17 15:50:57 +00:00
#include <WebContent/BackingStoreManager.h>
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 16:34:38 +00:00
#include <WebContent/Forward.h>
namespace WebContent {
class PageClient final : public Web::PageClient {
LibWeb: Make Web::PageClient GC-allocated This is a first step towards simplifying the ownership model of Web::Page. Soon Web::Page will store its WebClient as a NonnullGCPtr to help solve lifetime issues of the client being destroyed before the page.
2023-12-04 08:40:33 +00:00
JS_CELL(PageClient, Web::PageClient);
WebContent+WebWorker: Add calls to JS_{DECLARE,DEFINE}_ALLOCATOR()
2024-04-06 17:16:18 +00:00
JS_DECLARE_ALLOCATOR(PageClient);
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 16:34:38 +00:00
public:
LibWeb: Make Web::PageClient GC-allocated This is a first step towards simplifying the ownership model of Web::Page. Soon Web::Page will store its WebClient as a NonnullGCPtr to help solve lifetime issues of the client being destroyed before the page.
2023-12-04 08:40:33 +00:00
static JS::NonnullGCPtr<PageClient> create(JS::VM& vm, PageHost& page_host, u64 id);
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 16:34:38 +00:00
Everywhere: Write dtors for types with incomplete members out-of-line These are rejected by Clang (19) trunk as a result of https://github.com/llvm/llvm-project/pull/77753.
2024-06-16 08:38:35 +00:00
virtual ~PageClient() override;
Ladybird+LibWeb+WebContent: Always use Skia CPU backend in tests mode Enforce the use of the CPU backend in test mode to ensure that ref-tests produce consistent results across different computers, as this consistency cannot be achieved with the GPU backend.
2024-07-17 11:13:32 +00:00
enum class UseSkiaPainter {
CPUBackend,
GPUBackendIfAvailable,
};
static void set_use_skia_painter(UseSkiaPainter);
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 16:34:38 +00:00
LibWeb: Schedule repainting from EventLoop::process() In this change, updating layout and painting are moved to the EventLoop processing steps. This modification allows the addition of resize observation dispatching that needs to happen in event loop processing steps and must occur in the following order relative to layout and painting: 1. Update layout. 2. Gather and broadcast resize observations. 3. Paint.
2024-02-18 18:40:11 +00:00
virtual void schedule_repaint() override;
LibWeb: Add basic implementation of has_a_rendering_opportunity() Return true only if we are ready to repaint. This fixes the issue where requestAnimationFrame() was invoked more than once between repaints.
2024-03-18 19:11:06 +00:00
virtual bool is_ready_to_paint() const override;
LibWebView+WebContent: Drive repainting from WebContent process With this change, chrome no longer has to ask the WebContent process to paint the next frame into a specified bitmap. Instead, it allocates bitmaps and sends them to WebContent, which then lets chrome know when the painting is done. This work is a preparation to move the execution of painting commands into a separate thread. Now, it is much easier to start working on the next frame while the current one is still rendering. This is because WebContent does not have to inform chrome that the current frame is ready before it can request the next frame. Additionally, as a side bonus, we can now eliminate the did_invalidate_content_rect and did_change_selection IPC calls. These were used solely for the purpose of informing chrome that it needed to request a repaint.
2023-12-21 21:58:54 +00: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 16:34:38 +00:00
virtual Web::Page& page() override { return *m_page; }
virtual Web::Page const& page() const override { return *m_page; }
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 14:19:34 +00:00
ErrorOr<void> connect_to_webdriver(ByteString const& webdriver_ipc_path);
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 16:34:38 +00:00
LibWeb+WebContent: Change event loop to synchronously paint next frame ...instead of scheduling repaint timer in PageClient. This change fixes flickering on Discord that happened because: - Event loop schedules repainting by activating repaint timer - `Document::tear_down_layout_tree()` destroys paintable tree - Repaint timer invokes callback and renders an empty frame because paintable tree was destroyed
2024-05-28 13:51:53 +00:00
virtual void paint_next_frame() override;
LibWeb: Stop deadlocking on unit tests Unit tests on macOS deadlock because the WebContent process is waiting for the next opportunity to render before a screenshot is taken. For some reason unknown to myself, this opportunity never arrives. In order to not deadlock, screenshot requests are now also processed separately from rendering.
2024-07-03 12:12:28 +00:00
virtual void process_screenshot_requests() override;
Everywhere: Pass backing store into Navigable::paint() ...instead of Gfx::Bitmap, which makes it possible to access and directly paint into IOSurface on macOS.
2024-06-25 14:43:39 +00:00
virtual void paint(Web::DevicePixelRect const& content_rect, Web::Painting::BackingStore&, Web::PaintOptions = {}) 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 16:34:38 +00:00
void set_palette_impl(Gfx::PaletteImpl&);
LibWeb+WebContent: Move scrollbar painting into WebContent The main intention of this change is to have a consistent look and behavior across all scrollbars, including elements with `overflow: scroll` and `overflow: auto`, iframes, and a page. Before: - Page's scrollbar is painted by Browser (Qt/AppKit) using the corresponding UI framework style, - Both WebContent and Browser know the scroll position offset. - WebContent uses did_request_scroll_to() IPC call to send updates. - Browser uses set_viewport_rect() to send updates. After: - Page's scrollbar is painted on WebContent side using the same style as currently used for elements with `overflow: scroll` and `overflow: auto`. A nice side effects: scrollbars are now painted for iframes, and page's scrollbar respects scrollbar-width CSS property. - Only WebContent knows scroll position offset. - did_request_scroll_to() is no longer used. - set_viewport_rect() is changed to set_viewport_size().
2024-06-03 14:53:55 +00:00
void set_viewport_size(Web::DevicePixelSize const&);
LibWeb: Refactor int types in WebContentServer to DevicePixels
2023-12-14 06:17:00 +00:00
void set_screen_rects(Vector<Web::DevicePixelRect, 4> const& rects, size_t main_screen_index) { m_screen_rect = rects[main_screen_index]; }
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 16:34:38 +00:00
void set_device_pixels_per_css_pixel(float device_pixels_per_css_pixel) { m_device_pixels_per_css_pixel = device_pixels_per_css_pixel; }
void set_preferred_color_scheme(Web::CSS::PreferredColorScheme);
LibWeb: Add Contrast preference
2024-06-12 23:03:56 +00:00
void set_preferred_contrast(Web::CSS::PreferredContrast);
LibWeb: Add motion preference This adds a motion preference to the browser UI similar to the existing ones for color scheme and contrast. Both AppKit UI and Qt UI has this new preference. The auto value is currently the same as NoPreference, follow-ups can address wiring that up to the actual preference for the OS.
2024-06-13 14:15:59 +00:00
void set_preferred_motion(Web::CSS::PreferredMotion);
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 16:34:38 +00:00
void set_should_show_line_box_borders(bool b) { m_should_show_line_box_borders = b; }
void set_has_focus(bool);
void set_is_scripting_enabled(bool);
void set_window_position(Web::DevicePixelPoint);
void set_window_size(Web::DevicePixelSize);
Web::DevicePixelSize content_size() const { return m_content_size; }
Web::WebIDL::ExceptionOr<void> toggle_media_play_state();
void toggle_media_mute_state();
Web::WebIDL::ExceptionOr<void> toggle_media_loop_state();
Web::WebIDL::ExceptionOr<void> toggle_media_controls_state();
void alert_closed();
void confirm_closed(bool accepted);
void prompt_closed(Optional<String> response);
LibWeb: Allow input color to give continuous updates
2023-12-11 05:53:10 +00:00
void color_picker_update(Optional<Color> picked_color, Web::HTML::ColorPickerUpdateState state);
LibWeb: Refactor SelectItem to allow selecting options without value Currently the `<select>` dropdown IPC uses the option value attr to find which option is selected. This won't work when options don't have values or when multiple options have the same value. Also the `SelectItem` contained so weird recursive structures that are impossible to create with HTML. So I refactored `SelectItem` as a variant, and gave the options a unique id. The id is send back to `HTMLSelectElement` so it can find out exactly which option element is selected.
2024-04-03 17:19:08 +00:00
void select_dropdown_closed(Optional<u32> const& selected_item_id);
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 16:34:38 +00:00
void set_user_style(String source);
LibWebView+WebContent: Let the WebView client broadcast when it painted When the WebContent process has painted to its shared bitmaps, it sends a synchronous IPC to the browser process to let the chrome paint. It is synchronous to ensure the WC process doesn't paint onto the backing bitmap again while it is being displayed. However, this can cause a crash at exit if the browser process quits while the WC process is waiting for a response to this IPC. This patch makes the painting logic asynchronous by letting the browser process broadcast when it has finished handling the paint IPC. The WC process will not paint anything again until it receives that message. If it had tried to repaint while waiting for that message, that paint will be deferred until it arrives.
2024-01-07 15:35:45 +00:00
void ready_to_paint();
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-03 01:00:48 +00:00
void initialize_js_console(Web::DOM::Document& document);
void js_console_input(ByteString const& js_source);
void run_javascript(ByteString const& js_source);
void js_console_request_messages(i32 start_index);
void did_output_js_console_message(i32 message_index);
void console_peer_did_misbehave(char const* reason);
void did_get_js_console_messages(i32 start_index, Vector<ByteString> message_types, Vector<ByteString> messages);
LibWeb: Add method for listing all style sheets on a page This will be used by the inspector, for showing style sheet contents. Identifying a specific style sheet is a bit tricky. Depending on where it came from, a style sheet may have a URL, it might be associated with a DOM element, both, or neither. This varied information is wrapped in a new StyleSheetIdentifier struct.
2024-08-23 09:42:35 +00:00
Vector<Web::CSS::StyleSheetIdentifier> list_style_sheets() const;
LibWeb+WebContent: Move paint recording init into Navigable This refactoring makes WebContent less aware of LibWeb internals. The code that initializes paint recording commands now resides in `Navigable::paint()`. Additionally, we no longer need to reuse PaintContext across iframes, allowing us to avoid saving and restoring its state before recursing into an iframe.
2024-01-15 10:28:21 +00:00
virtual double device_pixels_per_css_pixel() const override { return m_device_pixels_per_css_pixel; }
LibWeb: Rename CommandExecutor to DisplayListPlayer Use more widely recognized name among browser engine developers.
2024-06-23 16:42:39 +00:00
virtual Web::DisplayListPlayerType display_list_player_type() const override;
LibWeb+WebContent+WebWorker: Allow to query painter type from PageClient Now it's possible to query selected type from SVGPageClient.
2024-06-19 11:46:27 +00:00
WebContent: Move screenshot requests handling into repaint loop This change ensures that if a screenshot is requested between teardown of paintable tree and relayout, we will wait for layout to complete before taking a screenshot.
2024-06-21 16:15:32 +00:00
void queue_screenshot_task(Optional<i32> node_id);
LibWebView+WebContent: Move backing store allocation into WebContent In the upcoming changes, we are going to switch macOS to using an IOSurface for the backing store. This change will simplify the process of sharing an IOSurface between processes because we already have the MachPortServer running in the browser, and WebContent knows how to locate the corresponding server.
2024-06-17 15:50:57 +00:00
friend class BackingStoreManager;
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 16:34:38 +00:00
private:
LibWeb: Make Web::PageClient GC-allocated This is a first step towards simplifying the ownership model of Web::Page. Soon Web::Page will store its WebClient as a NonnullGCPtr to help solve lifetime issues of the client being destroyed before the page.
2023-12-04 08:40:33 +00:00
PageClient(PageHost&, u64 id);
LibWeb: Make Web::Page GC-allocated This is a first step towards removing the various Page& and Page* we have littering the engine with "trust me bro" safety guarantees. Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-12-04 08:57:13 +00:00
virtual void visit_edges(JS::Cell::Visitor&) 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 16:34:38 +00:00
// ^PageClient
virtual bool is_connection_open() const override;
virtual Gfx::Palette palette() const override;
virtual Web::DevicePixelRect screen_rect() const override { return m_screen_rect; }
virtual Web::CSS::PreferredColorScheme preferred_color_scheme() const override { return m_preferred_color_scheme; }
LibWeb: Add Contrast preference
2024-06-12 23:03:56 +00:00
virtual Web::CSS::PreferredContrast preferred_contrast() const override { return m_preferred_contrast; }
LibWeb: Add motion preference This adds a motion preference to the browser UI similar to the existing ones for color scheme and contrast. Both AppKit UI and Qt UI has this new preference. The auto value is currently the same as NoPreference, follow-ups can address wiring that up to the actual preference for the OS.
2024-06-13 14:15:59 +00:00
virtual Web::CSS::PreferredMotion preferred_motion() const override { return m_preferred_motion; }
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 16:34:38 +00:00
virtual void page_did_request_cursor_change(Gfx::StandardCursor) override;
virtual void page_did_layout() 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 14:19:34 +00:00
virtual void page_did_change_title(ByteString const&) override;
LibWeb+LibWebView+WebContent: Add did_change_url() IPC call
2024-04-14 08:27:20 +00:00
virtual void page_did_change_url(URL::URL const&) 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 16:34:38 +00:00
virtual void page_did_request_navigate_back() override;
virtual void page_did_request_navigate_forward() override;
virtual void page_did_request_refresh() override;
virtual Gfx::IntSize page_did_request_resize_window(Gfx::IntSize) override;
virtual Gfx::IntPoint page_did_request_reposition_window(Gfx::IntPoint) override;
virtual void page_did_request_restore_window() override;
virtual Gfx::IntRect page_did_request_maximize_window() override;
virtual Gfx::IntRect page_did_request_minimize_window() override;
virtual Gfx::IntRect page_did_request_fullscreen_window() override;
LibWeb+UI: Add tooltip overriding and use it for <video> tags This call is used to inform the chrome that it should display a tooltip now and avoid any hovering timers. This is used by <video> tags to display the volume percentage when it is changed.
2024-07-02 14:48:57 +00:00
virtual void page_did_request_tooltip_override(Web::CSSPixelPoint, ByteString const&) override;
virtual void page_did_stop_tooltip_override() override;
LibWeb+UI/Qt: Display 'title' tooltips only when the mouse stops moving Now instead of sending the position in which the user entered the tooltip area, send just the text, and let the chrome figure out how to display it. In the case of Qt, wait for 600 milliseconds of no mouse movement, then display it under the mouse cursor.
2024-07-02 12:16:24 +00:00
virtual void page_did_enter_tooltip_area(ByteString const&) 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 16:34:38 +00:00
virtual void page_did_leave_tooltip_area() override;
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-29 02:02:55 +00:00
virtual void page_did_hover_link(URL::URL const&) 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 16:34:38 +00:00
virtual void page_did_unhover_link() override;
LibWeb+WebContent: Add a page hook to invoke the did-click-link IPC
2024-08-01 17:38:21 +00:00
virtual void page_did_click_link(URL::URL const&, ByteString const& target, unsigned modifiers) override;
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-29 02:02:55 +00:00
virtual void page_did_middle_click_link(URL::URL const&, ByteString const& target, unsigned modifiers) 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 16:34:38 +00:00
virtual void page_did_request_context_menu(Web::CSSPixelPoint) override;
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 03:22:27 +00:00
virtual void page_did_request_link_context_menu(Web::CSSPixelPoint, URL::URL const&, ByteString const& target, unsigned modifiers) override;
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-29 02:02:55 +00:00
virtual void page_did_request_image_context_menu(Web::CSSPixelPoint, URL::URL const&, ByteString const& target, unsigned modifiers, Gfx::Bitmap 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 14:19:34 +00:00
virtual void page_did_request_media_context_menu(Web::CSSPixelPoint, ByteString const& target, unsigned modifiers, Web::Page::MediaContextMenu) override;
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-29 02:02:55 +00:00
virtual void page_did_start_loading(URL::URL const&, bool) 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 16:34:38 +00:00
virtual void page_did_create_new_document(Web::DOM::Document&) override;
LibWeb+WebContent: Initialise JS console from Document::initialize() Before this change JS console was initialise from activate_history_entry() which is too late for about:blank documents that are ready to run scripts immediately after creation.
2024-04-11 15:21:09 +00:00
virtual void page_did_change_active_document_in_top_level_browsing_context(Web::DOM::Document&) override;
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-29 02:02:55 +00:00
virtual void page_did_finish_loading(URL::URL const&) 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 16:34:38 +00:00
virtual void page_did_request_alert(String const&) override;
virtual void page_did_request_confirm(String const&) override;
virtual void page_did_request_prompt(String const&, String const&) override;
virtual void page_did_request_set_prompt_text(String const&) override;
virtual void page_did_request_accept_dialog() override;
virtual void page_did_request_dismiss_dialog() override;
virtual void page_did_change_favicon(Gfx::Bitmap const&) override;
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 03:22:27 +00:00
virtual Vector<Web::Cookie::Cookie> page_did_request_all_cookies(URL::URL const&) override;
virtual Optional<Web::Cookie::Cookie> page_did_request_named_cookie(URL::URL const&, String const&) override;
LibWeb+LibWebView+WebContent: Convert URL declarations to east-const
2024-03-29 02:02:55 +00:00
virtual String page_did_request_cookie(URL::URL const&, Web::Cookie::Source) override;
virtual void page_did_set_cookie(URL::URL const&, Web::Cookie::ParsedCookie const&, Web::Cookie::Source) 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 16:34:38 +00:00
virtual void page_did_update_cookie(Web::Cookie::Cookie) override;
virtual void page_did_update_resource_count(i32) override;
LibWeb: Create a new WebView for window.open()'d top level traversables
2024-01-31 03:55:24 +00:00
virtual NewWebViewResult page_did_request_new_web_view(Web::HTML::ActivateTab, Web::HTML::WebViewHints, Web::HTML::TokenizedFeature::NoOpener) 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 16:34:38 +00:00
virtual void page_did_request_activate_tab() override;
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-03 01:00:48 +00:00
virtual void page_did_close_top_level_traversable() override;
LibWeb+LibWebView+WebContent: Add did_update_navigation_buttons_state() It is going to be used to communicate whether it is possible to navigate back or forward after session history stored on browser side will no longer be used to driver navigation.
2024-04-13 21:12:55 +00:00
virtual void page_did_update_navigation_buttons_state(bool back_enabled, bool forward_enabled) 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 16:34:38 +00:00
virtual void request_file(Web::FileRequest) override;
virtual void page_did_request_color_picker(Color current_color) override;
Ladybird+LibWeb+WebContent: Parse the <input type=file> accept attribute This parses the accept attribute value for file input types and passes it along to the browser chromes.
2024-03-14 16:26:00 +00:00
virtual void page_did_request_file_picker(Web::HTML::FileFilter accepted_file_types, Web::HTML::AllowMultipleFiles) override;
LibWeb: Make request_select_dropdown more similar to context menu api
2023-12-12 21:35:37 +00:00
virtual void page_did_request_select_dropdown(Web::CSSPixelPoint content_position, Web::CSSPixels minimum_width, Vector<Web::HTML::SelectItem> items) 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 16:34:38 +00:00
virtual void page_did_finish_text_test() override;
virtual void page_did_change_theme_color(Gfx::Color color) override;
virtual void page_did_insert_clipboard_entry(String data, String presentation_style, String mime_type) override;
LibWeb+LibWebView+WebContent: Inform chromes when audio is played/paused Most browsers have some indicator when audio is playing in a tab, which makes it easier to find that tab and mute unwanted audio. This adds an IPC to allow the Ladybird chromes to do something similar.
2024-03-26 23:27:06 +00:00
virtual void page_did_change_audio_play_state(Web::HTML::AudioPlayState) override;
LibWebView+WebContent: Move backing store allocation into WebContent In the upcoming changes, we are going to switch macOS to using an IOSurface for the backing store. This change will simplify the process of sharing an IOSurface between processes because we already have the MachPortServer running in the browser, and WebContent knows how to locate the corresponding server.
2024-06-17 15:50:57 +00:00
virtual void page_did_allocate_backing_stores(i32 front_bitmap_id, Gfx::ShareableBitmap front_bitmap, i32 back_bitmap_id, Gfx::ShareableBitmap back_bitmap) override;
Ladybird+Userland: Remove use of unnecessary fd passing socket concept Now that LibIPC is using SCM_RIGHTS properly, we can go back to only having one socket laying around when needing to transfer fds to peers.
2024-04-18 00:44:39 +00:00
virtual IPC::File request_worker_agent() 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 16:34:38 +00:00
virtual void inspector_did_load() 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 08:00:03 +00:00
virtual void inspector_did_select_dom_node(i32 node_id, Optional<Web::CSS::Selector::PseudoElement::Type> const& pseudo_element) override;
LibWeb+LibWebView+WebContent: Add Inspector IPCs to manipulate DOM nodes This adds the IDL methods and IPC to forward DOM-editing events from the Inspector WebView to the Inspector client.
2023-12-03 16:49:08 +00:00
virtual void inspector_did_set_dom_node_text(i32 node_id, String const& text) override;
virtual void inspector_did_set_dom_node_tag(i32 node_id, String const& tag) override;
LibWeb+LibWebView+WebContent: Add an Inspector IPC to add DOM attributes
2023-12-05 21:43:14 +00:00
virtual void inspector_did_add_dom_node_attributes(i32 node_id, JS::NonnullGCPtr<Web::DOM::NamedNodeMap> attributes) override;
LibWeb+WebContent: Do not embed attributes as data in the Inspector HTML Attribute values may contain HTML, and may contain invalid HTML at that. If the latter occurs, let's not generate invalid Inspector HTML when we embed the attribute values as data attributes. Instead, cache the values in the InspectorClient, and embed just a lookup index into the HTML. This also nicely reduces the size of the generated HTML. The Inspector on https://github.com/SerenityOS/serenity reduces from 2.3MB to 1.9MB (about 318KB, or 13.8%).
2024-02-18 18:59:28 +00:00
virtual void inspector_did_replace_dom_node_attribute(i32 node_id, size_t attribute_index, JS::NonnullGCPtr<Web::DOM::NamedNodeMap> replacement_attributes) override;
virtual void inspector_did_request_dom_tree_context_menu(i32 node_id, Web::CSSPixelPoint position, String const& type, Optional<String> const& tag, Optional<size_t> const& attribute_index) override;
LibWebView: Add context menu support to the Inspector's cookie table The menu can currently support deleting a specific cookie or all cookies for the current page.
2024-09-06 17:22:16 +00:00
virtual void inspector_did_request_cookie_context_menu(size_t cookie_index, Web::CSSPixelPoint position) override;
Inspector: Add a basic style sheet inspector Choosing options from the `<select>` will load and display that style sheet's source text, with some checks to make sure that the text that just loaded is the one we currently want. The UI is a little goofy when scrolling, as it uses `position: sticky` which we don't implement yet. But that's just more motivation to implement it! :^)
2024-08-23 10:18:35 +00:00
virtual void inspector_did_request_style_sheet_source(Web::CSS::StyleSheetIdentifier const& stylesheet_source) override;
LibWeb+LibWebView+WebContent: Add an Inspector IPC to execute JavaScript The Inspector will have an <input> element to execute user-provided JS. This adds an IDL method and IPC to forward that JS from the Inspector WebView to the Inspector client.
2023-12-01 00:27:32 +00:00
virtual void inspector_did_execute_console_script(String const& script) override;
LibWeb+LibWebView: Add a button to the Inspector to export its contents When working on the Inspector's HTML, it's often kind of tricky to debug when an element is styled / positioned incorrectly. We don't have a way to inspect the Inspector itself. This adds a button to the Inspector to export its HTML/CSS/JS contents to the downloads directory. This allows for more easily testing changes, especially by opening the exported HTML in another browser's dev tools. We will ultimately likely remove this button (or make it hidden) by the time we are production-ready. But it's quite useful for now.
2024-08-19 16:11:39 +00:00
virtual void inspector_did_export_inspector_html(String const& script) 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 16:34:38 +00:00
Web::Layout::Viewport* layout_root();
void setup_palette();
ConnectionFromClient& client() const;
PageHost& m_owner;
LibWeb: Make Web::Page GC-allocated This is a first step towards removing the various Page& and Page* we have littering the engine with "trust me bro" safety guarantees. Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-12-04 08:57:13 +00:00
JS::NonnullGCPtr<Web::Page> m_page;
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 16:34:38 +00:00
RefPtr<Gfx::PaletteImpl> m_palette_impl;
Web::DevicePixelRect m_screen_rect;
Web::DevicePixelSize m_content_size;
float m_device_pixels_per_css_pixel { 1.0f };
u64 m_id { 0 };
bool m_should_show_line_box_borders { false };
bool m_has_focus { false };
LibWebView+WebContent: Let the WebView client broadcast when it painted When the WebContent process has painted to its shared bitmaps, it sends a synchronous IPC to the browser process to let the chrome paint. It is synchronous to ensure the WC process doesn't paint onto the backing bitmap again while it is being displayed. However, this can cause a crash at exit if the browser process quits while the WC process is waiting for a response to this IPC. This patch makes the painting logic asynchronous by letting the browser process broadcast when it has finished handling the paint IPC. The WC process will not paint anything again until it receives that message. If it had tried to repaint while waiting for that message, that paint will be deferred until it arrives.
2024-01-07 15:35:45 +00:00
enum class PaintState {
Ready,
WaitingForClient,
PaintWhenReady,
};
PaintState m_paint_state { PaintState::Ready };
LibWebView+WebContent: Drive repainting from WebContent process With this change, chrome no longer has to ask the WebContent process to paint the next frame into a specified bitmap. Instead, it allocates bitmaps and sends them to WebContent, which then lets chrome know when the painting is done. This work is a preparation to move the execution of painting commands into a separate thread. Now, it is much easier to start working on the next frame while the current one is still rendering. This is because WebContent does not have to inform chrome that the current frame is ready before it can request the next frame. Additionally, as a side bonus, we can now eliminate the did_invalidate_content_rect and did_change_selection IPC calls. These were used solely for the purpose of informing chrome that it needed to request a repaint.
2023-12-21 21:58:54 +00:00
WebContent: Move screenshot requests handling into repaint loop This change ensures that if a screenshot is requested between teardown of paintable tree and relayout, we will wait for layout to complete before taking a screenshot.
2024-06-21 16:15:32 +00:00
struct ScreenshotTask {
Optional<i32> node_id;
};
Queue<ScreenshotTask> m_screenshot_tasks;
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 16:34:38 +00:00
Web::CSS::PreferredColorScheme m_preferred_color_scheme { Web::CSS::PreferredColorScheme::Auto };
LibWeb: Add Contrast preference
2024-06-12 23:03:56 +00:00
Web::CSS::PreferredContrast m_preferred_contrast { Web::CSS::PreferredContrast::NoPreference };
LibWeb: Add motion preference This adds a motion preference to the browser UI similar to the existing ones for color scheme and contrast. Both AppKit UI and Qt UI has this new preference. The auto value is currently the same as NoPreference, follow-ups can address wiring that up to the actual preference for the OS.
2024-06-13 14:15:59 +00:00
Web::CSS::PreferredMotion m_preferred_motion { Web::CSS::PreferredMotion::NoPreference };
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 16:34:38 +00:00
RefPtr<WebDriverConnection> m_webdriver;
LibAccelGfx+LibWeb: Explicitly pass OpenGL context to Painter Let's not assume there is one global OpenGL context because it might change once we will start creating >1 page inside single WebContent process or contexts for WebGL.
2023-12-16 15:22:11 +00:00
LibWebView+WebContent: Move backing store allocation into WebContent In the upcoming changes, we are going to switch macOS to using an IOSurface for the backing store. This change will simplify the process of sharing an IOSurface between processes because we already have the MachPortServer running in the browser, and WebContent knows how to locate the corresponding server.
2024-06-17 15:50:57 +00:00
BackingStoreManager m_backing_store_manager;
Ladybird+WebContent: Update IPC calls to handle multiple traversables The IPC layer between chromes and LibWeb now understands that multiple top level traversables can live in each WebContent process. This largely mechanical change adds a billion page_id/page_index arguments to make sure that pages that end up opening new WebViews through mechanisms like window.open() still work properly with those extra windows.
2024-02-03 01:00:48 +00:00
WeakPtr<WebContentConsoleClient> m_top_level_document_console_client;
JS::Handle<JS::GlobalObject> m_console_global_object;
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 16:34:38 +00:00
};
}
Reference in a new issue Copy permalink