beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 23:50:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Userland/Libraries/LibWebView/ViewImplementation.h

216 lines
8.1 KiB
C
Raw Normal View History

LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 12:32:17 +00:00
/*
* Copyright (c) 2022, Andreas Kling <kling@serenityos.org>
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 20:22:14 +00:00
* Copyright (c) 2023, Linus Groh <linusg@serenityos.org>
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 12:32:17 +00:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Forward.h>
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
#include <AK/Function.h>
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 20:22:14 +00:00
#include <AK/String.h>
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 12:32:17 +00:00
#include <LibGfx/Forward.h>
#include <LibGfx/StandardCursor.h>
#include <LibWeb/Forward.h>
WebContent+Everywhere: Add an option to not activate new tabs over IPC WebDriver, for example, will want to create new tabs without activating them.
2023-03-20 22:39:20 +00:00
#include <LibWeb/HTML/ActivateTab.h>
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 12:32:17 +00:00
#include <LibWebView/Forward.h>
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
#include <LibWebView/WebContentClient.h>
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 12:32:17 +00:00
namespace WebView {
Ladybird+LibWebView: Add -P/--enable-callgrind-profiling option This adds a -P option to run Ladybird under callgrind. It starts with instrumentation disabled. To start capturing a profile (once Ladybird has launched) run `callgrind_control -i on` and to stop it again run `callgrind_control -i off`. P.s. This is pretty much stolen from Andreas (and is based on the patch everyone [that wants a profile] have been manually applying).
2023-04-15 00:04:28 +00:00
// Note: This only exists inside Serenity to avoid #ifdefs in all implementors of ViewImplementation.
enum class EnableCallgrindProfiling {
No,
Yes
};
LibWeb: Add `--layout-test-mode` flag to HeadlessBrowser The `layout-test-mode` flag changes the font to be SerenitySans as this is the font used for layout tests for cross-platform compatibility of tests.
2023-05-06 10:46:14 +00:00
enum class IsLayoutTestMode {
No,
Yes
};
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 12:32:17 +00:00
class ViewImplementation {
public:
virtual ~ViewImplementation() { }
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 20:22:14 +00:00
struct DOMNodeProperties {
String computed_style_json;
String resolved_style_json;
String custom_properties_json;
String node_box_sizing_json;
Browser+LibWebView: Load and Display ARIA Properites and State The inspector widget now has a new ARIA tab which displays an individual element's ARIA properties and state. The view itself is pretty basic for now, just being a table- there is definitely room for some better UX here but it's enough for a first cut.
2023-05-21 13:52:03 +00:00
String aria_properties_state_json;
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 20:22:14 +00:00
};
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
void set_url(Badge<WebContentClient>, AK::URL url) { m_url = move(url); }
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 20:30:06 +00:00
AK::URL const& url() const { return m_url; }
LibWebView: Add window handle in `ClientState` in `ViewImplementation` Add field for a handle that is going to be used by WebDriver to identify top-level browsing contexts. It is supposed to be populated by WebContent client during creation. Co-authored-by: Timothy Flynn <trflynn89@pm.me>
2023-03-16 15:24:30 +00:00
String const& handle() const { return m_client_state.client_handle; }
Ladybird+LibWebView: Move most of paint handling to LibWebView Storing the backup bitmap is the same across Browser and Ladybird. Just peform that work in LibWebView, and handle only the implementation- specific nuances within the browsers.
2023-05-20 14:50:05 +00:00
void server_did_paint(Badge<WebContentClient>, i32 bitmap_id, Gfx::IntSize size);
Ladybird+LibWebView: Move APIs which only repaint to LibWebView We can easily add hooks to notify the browsers of these events if any implementation-specific handling is needed in the future, but for now, these only repaint the client, which we can do in ViewImplementation.
2023-05-20 15:04:02 +00:00
void server_did_invalidate_content_rect(Badge<WebContentClient>, Gfx::IntRect rect);
void server_did_change_selection(Badge<WebContentClient>);
Ladybird+LibWebView: Move most of paint handling to LibWebView Storing the backup bitmap is the same across Browser and Ladybird. Just peform that work in LibWebView, and handle only the implementation- specific nuances within the browsers.
2023-05-20 14:50:05 +00:00
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 20:30:06 +00:00
void load(AK::URL const&);
Userland+Ladybird: Always specify url to be about:srcdoc in load_html() After moving to navigables, we started reusing the code that populates session history entries with the srcdoc attribute value from iframes in `Page::load_html()` for loading HTML. This change addresses a crash in `determine_the_origin` which occurred because this method expected the URL to be `about:srcdoc` if we also provided HTML content (previously, it was the URL passed along with the HTML content into `load_html()`).
2023-09-17 15:12:17 +00:00
void load_html(StringView);
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 20:30:06 +00:00
void load_empty_document();
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 19:49:49 +00:00
void zoom_in();
void zoom_out();
void reset_zoom();
LibWebView: Expose getter for current zoom level
2023-03-26 18:41:56 +00:00
float zoom_level() const { return m_zoom_level; }
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 20:22:14 +00:00
LibWebView+Ladybird: Move preferred color scheme to ViewImplementation
2023-01-12 20:44:42 +00:00
void set_preferred_color_scheme(Web::CSS::PreferredColorScheme);
LibWebView+Ladybird: Move text selection to ViewImplementation
2023-01-12 20:42:42 +00:00
DeprecatedString selected_text();
void select_all();
LibWebView+Ladybird: Move get source request to ViewImplementation
2023-01-12 19:58:00 +00:00
void get_source();
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 19:49:49 +00:00
LibWebView+Ladybird: Move DOM inspection helpers to ViewImplementation
2023-01-12 20:22:14 +00:00
void inspect_dom_tree();
void inspect_accessibility_tree();
ErrorOr<DOMNodeProperties> inspect_dom_node(i32 node_id, Optional<Web::CSS::Selector::PseudoElement> pseudo_element);
void clear_inspected_dom_node();
i32 get_hovered_node_id();
LibWebView+Ladybird: Move debug request to ViewImplementation
2023-01-12 20:34:08 +00:00
void debug_request(DeprecatedString const& request, DeprecatedString const& argument = {});
LibWebView+Ladybird: Move running JavaScript to ViewImplementation
2023-01-12 20:39:08 +00:00
void run_javascript(StringView);
Ladybird: Move ownership of the JS console/inspector to the tab object This is to match Browser, where ownership of all "subwidgets" is placed on the tab as well. This further lets us align the web view callbacks to match Browser's OOPWV as well, which will later let us move them into the base LibWebView class.
2023-05-17 15:54:36 +00:00
void js_console_input(DeprecatedString const& js_source);
void js_console_request_messages(i32 start_index);
LibWebView+Ladybird: Move running JavaScript to ViewImplementation
2023-01-12 20:39:08 +00:00
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 18:23:34 +00:00
void alert_closed();
void confirm_closed(bool accepted);
void prompt_closed(Optional<String> response);
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 14:51:38 +00:00
void toggle_media_play_state();
Ladybird+LibWeb+WebContent: Add context menu controls for muting audio
2023-06-16 15:29:54 +00:00
void toggle_media_mute_state();
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 14:51:38 +00:00
void toggle_media_loop_state();
void toggle_media_controls_state();
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 15:17:58 +00:00
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 13:53:13 +00:00
enum class ScreenshotType {
Visible,
Full,
};
ErrorOr<void> take_screenshot(ScreenshotType);
LibWebView: Allow using native/user style sheets on Lagom Move the methods to set the native/user style sheets to the base ViewImplementation class. We must also generate the native style sheet explicitly for now, as LibWebView on Lagom isn't able to include the main LibWebView CMakeLists.txt file yet.
2023-08-26 17:34:59 +00:00
void set_user_style_sheet(String source);
// Load Native.css as the User style sheet, which attempts to make WebView content look as close to
// native GUI widgets as possible.
void use_native_user_style_sheet();
Ladybird+LibWebView: Migrate layout notification to LibWebView callbacks
2023-08-23 14:33:26 +00:00
Function<void(Gfx::IntSize)> on_did_layout;
Ladybird+LibWebView: Move most of paint handling to LibWebView Storing the backup bitmap is the same across Browser and Ladybird. Just peform that work in LibWebView, and handle only the implementation- specific nuances within the browsers.
2023-05-20 14:50:05 +00:00
Function<void()> on_ready_to_paint;
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
Function<String(Web::HTML::ActivateTab)> on_new_tab;
Function<void()> on_activate_tab;
Function<void()> on_close;
Function<void(Gfx::IntPoint screen_position)> on_context_menu_request;
Function<void(const AK::URL&, Gfx::IntPoint screen_position)> on_link_context_menu_request;
Function<void(const AK::URL&, Gfx::IntPoint screen_position, Gfx::ShareableBitmap const&)> on_image_context_menu_request;
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 14:51:38 +00:00
Function<void(Gfx::IntPoint screen_position, Web::Page::MediaContextMenu const&)> on_media_context_menu_request;
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
Function<void(const AK::URL&)> on_link_hover;
Function<void()> on_link_unhover;
Function<void(const AK::URL&, DeprecatedString const& target, unsigned modifiers)> on_link_click;
Function<void(const AK::URL&, DeprecatedString const& target, unsigned modifiers)> on_link_middle_click;
Function<void(DeprecatedString const&)> on_title_change;
Function<void(const AK::URL&, bool)> on_load_start;
Function<void(const AK::URL&)> on_load_finish;
Ladybird+LibWebView: Migrate file APIs to LibWebView callbacks This also sets the default callback to do what every non-Serenity browser is doing, rather than copy-pasting this callback into every implementation. The callback is still available for any platform which might want to override the default behavior. For example, OOPWV now overrides this callback to use FileSystemAccessClient.
2023-08-23 10:54:22 +00:00
Function<void(DeprecatedString const& path, i32)> on_request_file;
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
Function<void()> on_navigate_back;
Function<void()> on_navigate_forward;
Function<void()> on_refresh;
Function<void(Gfx::Bitmap const&)> on_favicon_change;
Ladybird+LibWebView: Migrate scrolling changes to LibWebView callbacks
2023-08-23 14:57:09 +00:00
Function<void(i32, i32)> on_scroll_by_delta;
Function<void(Gfx::IntPoint)> on_scroll_to_point;
Function<void(Gfx::IntRect)> on_scroll_into_view;
Ladybird+LibWebView: Migrate cursor changes to LibWebView callbacks
2023-08-23 14:43:27 +00:00
Function<void(Gfx::StandardCursor)> on_cursor_change;
Ladybird+LibWebView: Migrate tooltip changes to LibWebView callbacks
2023-08-23 15:11:39 +00:00
Function<void(Gfx::IntPoint, DeprecatedString const&)> on_enter_tooltip_area;
Function<void()> on_leave_tooltip_area;
Ladybird+LibWebView: Migrate dialog APIs to LibWebView callbacks
2023-05-17 18:23:34 +00:00
Function<void(String const& message)> on_request_alert;
Function<void(String const& message)> on_request_confirm;
Function<void(String const& message, String const& default_)> on_request_prompt;
Function<void(String const& message)> on_request_set_prompt_text;
Function<void()> on_request_accept_dialog;
Function<void()> on_request_dismiss_dialog;
Ladybird+LibWebView: Rename some "on get" notifications to "on received" The old names sounded like awkward English to me, as they implied the WebContent process is asking for information. In reality, WebContent is *providing* the information.
2023-08-23 15:25:24 +00:00
Function<void(const AK::URL&, DeprecatedString const&)> on_received_source;
Function<void(DeprecatedString const&)> on_received_dom_tree;
Function<void(i32 node_id, DeprecatedString const& computed_style, DeprecatedString const& resolved_style, DeprecatedString const& custom_properties, DeprecatedString const& node_box_sizing, DeprecatedString const& aria_properties_state)> on_received_dom_node_properties;
Function<void(DeprecatedString const&)> on_received_accessibility_tree;
Function<void(i32 message_id)> on_received_console_message;
Function<void(i32 start_index, Vector<DeprecatedString> const& message_types, Vector<DeprecatedString> const& messages)> on_received_console_messages;
Browser+Ladybird+LibWebView: Handle trivial content APIs in LibWebView The goal here is to reduce the amount of WebContent client APIs that are duplicated across every ViewImplementation. Across our three browsers, we currently: Ladybird - Mix some AK::Function callbacks and Qt signals to notify tabs of WebContent events. Browser - Use only AK::Function callbacks. headless-browser - Drop most events on the floor. Instead, let's only use AK::Function callbacks across all three browsers to propagate events to tabs. This allows us to invoke those callbacks directly from LibWebView instead of all three browsers needing to define a trivial `if (callback) callback();` override of a LibWebView virtual function. For headless-browser, we can simply not set these callbacks. As a first pass, this only converts WebContent events that are trivial to this approach. That is, events that were simply passed onto the tab or handled without much fuss.
2023-05-17 16:37:31 +00:00
Function<Vector<Web::Cookie::Cookie>(AK::URL const& url)> on_get_all_cookies;
Function<Optional<Web::Cookie::Cookie>(AK::URL const& url, DeprecatedString const& name)> on_get_named_cookie;
Function<DeprecatedString(const AK::URL& url, Web::Cookie::Source source)> on_get_cookie;
Function<void(const AK::URL& url, Web::Cookie::ParsedCookie const& cookie, Web::Cookie::Source source)> on_set_cookie;
Function<void(Web::Cookie::Cookie const& cookie)> on_update_cookie;
Function<void(i32 count_waiting)> on_resource_status_change;
Function<void()> on_restore_window;
Function<Gfx::IntPoint(Gfx::IntPoint)> on_reposition_window;
Function<Gfx::IntSize(Gfx::IntSize)> on_resize_window;
Function<Gfx::IntRect()> on_maximize_window;
Function<Gfx::IntRect()> on_minimize_window;
Function<Gfx::IntRect()> on_fullscreen_window;
Ladybird+LibWebView: Migrate input completions to LibWebView callbacks
2023-08-23 15:19:21 +00:00
Function<void(bool)> on_finish_handling_input_event;
LibWeb+WebContent+headless-browser: Support async text tests Previously, we used `on_load_finish` to determine when the text test was completed. This method did not allow testing of async functions because there was no way to indicate that the runner should wait for the async call to end. This change introduces a function in the `internals` object that is intended to be called when the text test execution is completed. The text test runner will now ignore `on_load_finish` which means a test will timeout if this new function is never called. `test(f)` function in `include.js` has been modified to automatically terminate a test once `load` event is fired on `window`. new `asyncTest(f)` function has been introduces. `f` receives function that will terminate a test as a first argument. Every test is expected to call either `test()` or `asyncTest()` to complete. If not, it will remain hanging until a timeout occurs.
2023-09-14 17:17:32 +00:00
Function<void()> on_text_test_finish;
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 05:59:51 +00:00
virtual Gfx::IntRect viewport_rect() const = 0;
Browser+Ladybird+LibWebView: Virtualize computing content/widget points This will allow moving some copy-pasted functionality from web view implementations to the base LibWebView class.
2023-05-17 14:12:13 +00:00
virtual Gfx::IntPoint to_content_position(Gfx::IntPoint widget_position) const = 0;
virtual Gfx::IntPoint to_widget_position(Gfx::IntPoint content_position) const = 0;
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 05:59:51 +00:00
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
protected:
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 19:49:49 +00:00
static constexpr auto ZOOM_MIN_LEVEL = 0.3f;
static constexpr auto ZOOM_MAX_LEVEL = 5.0f;
static constexpr auto ZOOM_STEP = 0.1f;
Ladybird+LibWebView+Browser: Remove ability to run with AST interpreter
2023-08-07 14:44:20 +00:00
ViewImplementation();
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 05:59:51 +00:00
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
WebContentClient& client();
WebContentClient const& client() const;
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 19:49:49 +00:00
virtual void update_zoom() = 0;
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 05:59:51 +00:00
enum class WindowResizeInProgress {
No,
Yes,
};
void resize_backing_stores_if_needed(WindowResizeInProgress);
void request_repaint();
void handle_resize();
Ladybird+LibWebView: Respawn with same JS interpreter after crash WebView::ViewImplementation now remembers which JS interpreter it started with, and uses the same setting if the WebContent process crashes and we have to spawn a new one.
2023-07-22 10:41:25 +00:00
virtual void create_client(EnableCallgrindProfiling = EnableCallgrindProfiling::No) { }
Ladybird+LibWebView: Add -P/--enable-callgrind-profiling option This adds a -P option to run Ladybird under callgrind. It starts with instrumentation disabled. To start capturing a profile (once Ladybird has launched) run `callgrind_control -i on` and to stop it again run `callgrind_control -i off`. P.s. This is pretty much stolen from Andreas (and is based on the patch everyone [that wants a profile] have been manually applying).
2023-04-15 00:04:28 +00:00
Browser+Ladybird+LibWebView: Move some common functions to LibWebView The implementations of handle_web_content_process_crash and take_screenshot are exactly the same across Browser and Ladybird. Let's reduce some code duplication and move them to LibWebView.
2023-05-17 13:53:13 +00:00
void handle_web_content_process_crash();
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
struct SharedBitmap {
i32 id { -1 };
i32 pending_paints { 0 };
Ladybird+LibWebView: Remember the size of the last paint This will allow us to change the size of the backing store bitmap without conflating the size of the bitmap and the size of the paint.
2023-05-14 16:53:29 +00:00
Gfx::IntSize last_painted_size;
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
RefPtr<Gfx::Bitmap> bitmap;
};
struct ClientState {
RefPtr<WebContentClient> client;
LibWebView: Add window handle in `ClientState` in `ViewImplementation` Add field for a handle that is going to be used by WebDriver to identify top-level browsing contexts. It is supposed to be populated by WebContent client during creation. Co-authored-by: Timothy Flynn <trflynn89@pm.me>
2023-03-16 15:24:30 +00:00
String client_handle;
LibWebView+Ladybird: Begin de-duplicate WebView implementations This starts moving code equally shared between the OOPWV and Ladybird WebContentView implementations to WebView::ViewImplementation, beginning with the client state.
2023-01-12 19:27:17 +00:00
SharedBitmap front_bitmap;
SharedBitmap back_bitmap;
i32 next_bitmap_id { 0 };
bool has_usable_bitmap { false };
bool got_repaint_requests_while_painting { false };
} m_client_state;
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 19:49:49 +00:00
LibWebView+Ladybird: Move page loading to ViewImplementation
2023-01-12 20:30:06 +00:00
AK::URL m_url;
LibWebView+Ladybird: Move zoom logic to ViewImplementation
2023-01-12 19:49:49 +00:00
float m_zoom_level { 1.0 };
float m_device_pixel_ratio { 1.0 };
Ladybird+LibWebView: Move backing store management code to LibWebView This lets us share this code on all platforms, and makes resizing the window much faster on SerenityOS as well. :^)
2023-05-15 05:59:51 +00:00
RefPtr<Core::Timer> m_backing_store_shrink_timer;
RefPtr<Gfx::Bitmap> m_backup_bitmap;
Gfx::IntSize m_backup_bitmap_size;
LibWebView: Don't re-create WebContent proceses when repeatedly crashing Serenity handles this in the SystemServer already, but the simplest place to put this logic is the ViewImplementation base class. This is trivial to see when running Ladybird without SERENTIY_SOURCE_DIR set, or set improperly.
2023-05-27 16:46:45 +00:00
size_t m_crash_count = 0;
RefPtr<Core::Timer> m_repeated_crash_timer;
LibWebView: Add abstract virtual base for WebView implementations This patch adds WebView::ViewImplementation with all the `notify_server_did_this_or_that()` functions from OOPWV. This will allow us to share code between different web views, paving the way for a Qt widget in Ladybird that can talk to a WebContent process.
2022-10-05 12:32:17 +00:00
};
}
Reference in a new issue Copy permalink