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

190 lines
12 KiB
C
Raw Normal View History

WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
/*
* Copyright (c) 2022, Florent Castelli <florent.castelli@gmail.com>
* Copyright (c) 2022, Linus Groh <linusg@serenityos.org>
LibWeb+WebContent+WebDriver: Allow specifying multiple prompt handlers WebDriver script authors may now provide either: * A user prompt handler configuration to be used for all prompt types. * A set of per-prompt-type user prompt handlers. This also paves the way for interaction with the beforeunload prompt, though we do not yet support that feature in LibWeb. See: https://github.com/w3c/webdriver/commit/43903d0
2025-02-05 11:36:19 -05:00
* Copyright (c) 2022-2025, Tim Flynn <trflynn89@ladybird.org>
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
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
#include <AK/ByteString.h>
LibWeb+WebContent+WebDriver: Port WebDriver parameters to String This changes the parameters parsed from a WebDriver HTTP request to String for transferring over IPC. Conveniently, most locations these were ultimately passed to only need a StringView.
2023-03-05 15:31:49 -05:00
#include <AK/String.h>
LibGC: Rename MarkedVector => RootVector Let's try to make it a bit more clear that this is a Vector of GC roots.
2024-12-26 14:32:52 +01:00
#include <LibGC/RootVector.h>
WebContent: Add missing LibGfx include
2023-02-25 10:43:09 -07:00
#include <LibGfx/Rect.h>
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
#include <LibIPC/ConnectionToServer.h>
LibIPC+Everywhere: Introduce an IPC Transport abstraction This abstraction will help us to support multiple IPC transport mechanisms going forward. For now, we only have a TransportSocket that implements the same behavior we previously had, using Unix Sockets for IPC.
2024-10-22 15:47:33 -06:00
#include <LibIPC/Transport.h>
WebContent+WebDriver: Move Execute Script to WebContent
2022-11-10 20:55:17 -05:00
#include <LibJS/Forward.h>
WebContent+WebDriver: Move Find Element to WebContent Note that this does nothing to "fix" how element references are created. We continue to return the element ID because, otherwise, all other element WebDriver endpoints would break. On the bright side, we avoid several IPC round trips now that we perform the entire 'find' operation in the WebContent process; and we are able to work directly on DOM nodes.
2022-11-09 15:02:38 -05:00
#include <LibWeb/Forward.h>
LibWeb+WebContent+WebDriver+UI: Make window min/maximize asynchronous This follows suit of previous changes to never block the WebContent process in WebDriver endpoints.
2024-10-28 23:45:18 -04:00
#include <LibWeb/HTML/VisibilityState.h>
WebContent+WebDriver: Move Find Element to WebContent Note that this does nothing to "fix" how element references are created. We continue to return the element ID because, otherwise, all other element WebDriver endpoints would break. On the bright side, we avoid several IPC round trips now that we perform the entire 'find' operation in the WebContent process; and we are able to work directly on DOM nodes.
2022-11-09 15:02:38 -05:00
#include <LibWeb/WebDriver/ElementLocationStrategies.h>
LibWeb+WebContent: Handle user prompts that open during script execution If a dialog is opened while a script is executing, we must give control back to the WebDriver client. The script must also continue executing though, so once it completes, we ignore its result.
2024-10-31 20:23:36 -04:00
#include <LibWeb/WebDriver/ExecuteScript.h>
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
#include <LibWeb/WebDriver/Response.h>
WebContent+WebDriver: Move Get/Set Timeouts to WebContent
2022-11-11 14:28:57 -05:00
#include <LibWeb/WebDriver/TimeoutsConfiguration.h>
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
#include <WebContent/Forward.h>
#include <WebContent/WebDriverClientEndpoint.h>
#include <WebContent/WebDriverServerEndpoint.h>
namespace WebContent {
WebContent+WebDriver: Make the element locator endpoints asynchronous We currently spin the event loop to wait for the specified element to become available. As we've seen with other endpoints, this can result in dead locks if another web component also spins the event loop. This patch makes the locator implementations asynchronous.
2024-10-30 15:26:04 -04:00
class ElementLocator;
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
class WebDriverConnection final
: public IPC::ConnectionToServer<WebDriverClientEndpoint, WebDriverServerEndpoint> {
WebContent: Disallow creating WebDriverConnections with existing sockets This reverts commit d2b2d3ad8062d2ce1612f24e4c45d533344a2be3. This is no longer needed once Ladybird will uses local socket files.
2022-12-15 08:44:10 -05:00
C_OBJECT_ABSTRACT(WebDriverConnection)
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
public:
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
static ErrorOr<NonnullRefPtr<WebDriverConnection>> connect(Web::PageClient& page_client, ByteString const& webdriver_ipc_path);
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
virtual ~WebDriverConnection() = default;
WebContent: Add a JS visitor to WebDriver's IPC connection We've added a few JS::Handle members to this class over time. Let's avoid creating a new GC root for each of these, and explicitly add a visitation method.
2024-10-17 18:50:36 -04:00
void visit_edges(JS::Cell::Visitor&);
WebContent+WebDriver: Asynchronously wait for navigations to complete Similar to commit c2cf65adac78912883996153fb608dafe389b6e0, we should avoid spinning the event loop from the WebContent-side of the WebDriver connection. This can result in deadlocks if another component in LibWeb also spins the event loop. The AO to await navigations has two event loop spinners - waiting for the navigation to complete and for the document to reach the target readiness state. We now use NavigationObserver and DocumentObserver to be notified when these conditions are met. And we use the same async IPC mechanism as script execution to notify the WebDriver process when all conditions are met (or timed out).
2024-10-25 10:28:29 -04:00
void page_did_open_dialog(Badge<PageClient>);
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
private:
LibIPC+Everywhere: Introduce an IPC Transport abstraction This abstraction will help us to support multiple IPC transport mechanisms going forward. For now, we only have a TransportSocket that implements the same behavior we previously had, using Unix Sockets for IPC.
2024-10-22 15:47:33 -06:00
WebDriverConnection(IPC::Transport transport, Web::PageClient& page_client);
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
virtual void die() override { }
WebContent+WebDriver: Fully implement closing a session There were a couple steps missing to close the remote end. Further, we were not removing the session from the list of active sessions.
2022-11-08 14:14:29 -05:00
virtual void close_session() override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 12:22:39 -05:00
virtual void set_page_load_strategy(Web::WebDriver::PageLoadStrategy page_load_strategy) override;
virtual void set_user_prompt_handler(Web::WebDriver::UserPromptHandler user_prompt_handler) override;
WebContent+WebDriver: Send the parsed capabilities over to WebContent
2022-11-17 16:27:32 -05:00
virtual void set_strict_file_interactability(bool strict_file_interactability) override;
WebContent+WebDriver: Set the navigator.webdriver flag from WebDriver This moves setting the navigator.webdriver flag from after WebContent creates the WebDriver connection, to its own IPC to be triggered from WebDriver. This is closer to the spec, but mostly serves as an easy test to validate the connection.
2022-11-08 10:42:12 -05:00
virtual void set_is_webdriver_active(bool) override;
WebContent+WebDriver: Move Get/Set Timeouts to WebContent
2022-11-11 14:28:57 -05:00
virtual Messages::WebDriverClient::GetTimeoutsResponse get_timeouts() override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 12:22:39 -05:00
virtual Messages::WebDriverClient::SetTimeoutsResponse set_timeouts(JsonValue payload) override;
virtual Messages::WebDriverClient::NavigateToResponse navigate_to(JsonValue payload) override;
WebContent+WebDriver: Move the Get Current URL command to WebContent
2022-11-08 13:06:22 -05:00
virtual Messages::WebDriverClient::GetCurrentUrlResponse get_current_url() override;
Browser+WebContent+WebDriver: Move Back, Forward, Refresh to WebContent
2022-11-11 13:46:22 -05:00
virtual Messages::WebDriverClient::BackResponse back() override;
virtual Messages::WebDriverClient::ForwardResponse forward() override;
virtual Messages::WebDriverClient::RefreshResponse refresh() override;
Browser+WebContent+WebDriver: Move Get Title to WebContent
2022-11-11 13:50:43 -05:00
virtual Messages::WebDriverClient::GetTitleResponse get_title() override;
WebContent+WebDriver: Get window handle from WebContent process This change makes window handles on WebDriver process side be consistent with handles returned by /window/new.
2023-03-13 17:45:34 +03:00
virtual Messages::WebDriverClient::GetWindowHandleResponse get_window_handle() override;
WebContent+WebDriver: Move Window commands to WebContent This moves Get Window Handle, Close Window, and Get Window Handles over to WebContent so they may be implemented closer to the spec and be used by Ladybird.
2022-11-14 11:55:10 -05:00
virtual Messages::WebDriverClient::CloseWindowResponse close_window() override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 12:22:39 -05:00
virtual Messages::WebDriverClient::SwitchToWindowResponse switch_to_window(String handle) override;
virtual Messages::WebDriverClient::NewWindowResponse new_window(JsonValue payload) override;
virtual Messages::WebDriverClient::SwitchToFrameResponse switch_to_frame(JsonValue payload) override;
virtual Messages::WebDriverClient::SwitchToParentFrameResponse switch_to_parent_frame(JsonValue payload) override;
Browser+WebContent+WebDriver: Move Get/Set Window Rect to WebContent This also lets us more fully implement the "restore the window" method, which requires we block until the document reaches the "visible" state.
2022-11-09 09:56:20 -05:00
virtual Messages::WebDriverClient::GetWindowRectResponse get_window_rect() override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 12:22:39 -05:00
virtual Messages::WebDriverClient::SetWindowRectResponse set_window_rect(JsonValue payload) override;
Browser+WebContent+WebDriver: Move [Max,Min]imize Window to WebContent This also lets us more fully implement the "iconify the window" method, which requires we block until the document reaches the "hidden" state.
2022-11-09 11:00:53 -05:00
virtual Messages::WebDriverClient::MaximizeWindowResponse maximize_window() override;
virtual Messages::WebDriverClient::MinimizeWindowResponse minimize_window() override;
WebDriver: Implement `POST /session/{id}/window/fullscreen` endpoint
2022-11-09 19:09:17 +01:00
virtual Messages::WebDriverClient::FullscreenWindowResponse fullscreen_window() override;
WebDriver+WebContent: Add /session/:id:/window/consume-user-activation This extension to the WebDriver spec is defined in the HTML spec, how fun.
2024-05-29 11:14:42 -06:00
virtual Messages::WebDriverClient::ConsumeUserActivationResponse consume_user_activation() override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 12:22:39 -05:00
virtual Messages::WebDriverClient::FindElementResponse find_element(JsonValue payload) override;
virtual Messages::WebDriverClient::FindElementsResponse find_elements(JsonValue payload) override;
virtual Messages::WebDriverClient::FindElementFromElementResponse find_element_from_element(JsonValue payload, String element_id) override;
virtual Messages::WebDriverClient::FindElementsFromElementResponse find_elements_from_element(JsonValue payload, String element_id) override;
virtual Messages::WebDriverClient::FindElementFromShadowRootResponse find_element_from_shadow_root(JsonValue payload, String shadow_id) override;
virtual Messages::WebDriverClient::FindElementsFromShadowRootResponse find_elements_from_shadow_root(JsonValue payload, String shadow_id) override;
LibWeb+WebContent+WebDriver: Implement Get Active Element Unfortunately, nothing ever calls DOM::Document::set_active_element at the moment, so this will always return ErrorCode::NoSuchElement.
2022-11-14 19:02:23 -05:00
virtual Messages::WebDriverClient::GetActiveElementResponse get_active_element() override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 12:22:39 -05:00
virtual Messages::WebDriverClient::GetElementShadowRootResponse get_element_shadow_root(String element_id) override;
virtual Messages::WebDriverClient::IsElementSelectedResponse is_element_selected(String element_id) override;
virtual Messages::WebDriverClient::GetElementAttributeResponse get_element_attribute(String element_id, String name) override;
virtual Messages::WebDriverClient::GetElementPropertyResponse get_element_property(String element_id, String name) override;
virtual Messages::WebDriverClient::GetElementCssValueResponse get_element_css_value(String element_id, String name) override;
virtual Messages::WebDriverClient::GetElementTextResponse get_element_text(String element_id) override;
virtual Messages::WebDriverClient::GetElementTagNameResponse get_element_tag_name(String element_id) override;
virtual Messages::WebDriverClient::GetElementRectResponse get_element_rect(String element_id) override;
virtual Messages::WebDriverClient::IsElementEnabledResponse is_element_enabled(String element_id) override;
virtual Messages::WebDriverClient::GetComputedRoleResponse get_computed_role(String element_id) override;
virtual Messages::WebDriverClient::GetComputedLabelResponse get_computed_label(String element_id) override;
virtual Messages::WebDriverClient::ElementClickResponse element_click(String element_id) override;
virtual Messages::WebDriverClient::ElementClearResponse element_clear(String element_id) override;
virtual Messages::WebDriverClient::ElementSendKeysResponse element_send_keys(String element_id, JsonValue payload) override;
Browser+WebContent+WebDriver: Move Get Page Source to WebContent
2022-11-10 18:00:01 -05:00
virtual Messages::WebDriverClient::GetSourceResponse get_source() override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 12:22:39 -05:00
virtual Messages::WebDriverClient::ExecuteScriptResponse execute_script(JsonValue payload) override;
virtual Messages::WebDriverClient::ExecuteAsyncScriptResponse execute_async_script(JsonValue payload) override;
Browser+WebContent+WebDriver: Move Get All Cookies to WebContent There are a couple changes here from the existing Get All Cookies implementation. 1. Previously, WebDriver actually returned *all* cookies in the cookie jar. The spec dictates that we only return cookies that match the document's URL. Specifically, it calls out that we must run just the first step of RFC 6265 section 5.4 to perform domain matching. This change adds a special mode to our implementation of that section to skip the remaining steps. 2. We now fill in the SameSite cookie attribute when serializing the cookie to JSON (this was a trival FIXME that didn't get picked up when SameSite was implemented).
2022-11-11 09:24:07 -05:00
virtual Messages::WebDriverClient::GetAllCookiesResponse get_all_cookies() override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 12:22:39 -05:00
virtual Messages::WebDriverClient::GetNamedCookieResponse get_named_cookie(String name) override;
virtual Messages::WebDriverClient::AddCookieResponse add_cookie(JsonValue payload) override;
virtual Messages::WebDriverClient::DeleteCookieResponse delete_cookie(String name) override;
Browser+WebContent+WebDriver: Move Delete All Cookies to WebContent
2022-11-11 11:27:08 -05:00
virtual Messages::WebDriverClient::DeleteAllCookiesResponse delete_all_cookies() override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 12:22:39 -05:00
virtual Messages::WebDriverClient::PerformActionsResponse perform_actions(JsonValue payload) override;
LibWeb: Stub out `Release Actions` This allows WPT to open the browser, and it no longer instantly crashes
2023-06-17 17:36:00 +02:00
virtual Messages::WebDriverClient::ReleaseActionsResponse release_actions() override;
LibWeb+WebContent+WebDriver: Implement Dismiss Alert
2022-11-16 07:15:57 -05:00
virtual Messages::WebDriverClient::DismissAlertResponse dismiss_alert() override;
LibWeb+WebContent+WebDriver: Implement Accept Alert
2022-11-16 07:24:22 -05:00
virtual Messages::WebDriverClient::AcceptAlertResponse accept_alert() override;
LibWeb+WebContent+WebDriver: Implement Get Alert Text
2022-11-16 08:26:48 -05:00
virtual Messages::WebDriverClient::GetAlertTextResponse get_alert_text() override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 12:22:39 -05:00
virtual Messages::WebDriverClient::SendAlertTextResponse send_alert_text(JsonValue payload) override;
Browser+WebContent+WebDriver: Move Take Screenshot to WebContent
2022-11-10 13:20:44 -05:00
virtual Messages::WebDriverClient::TakeScreenshotResponse take_screenshot() override;
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 12:22:39 -05:00
virtual Messages::WebDriverClient::TakeElementScreenshotResponse take_element_screenshot(String element_id) override;
virtual Messages::WebDriverClient::PrintPageResponse print_page(JsonValue payload) override;
WebContent+WebDriver: Ensure Get Window Handle checks for closed BCs
2023-03-07 11:29:14 -05:00
virtual Messages::WebDriverClient::EnsureTopLevelBrowsingContextIsOpenResponse ensure_top_level_browsing_context_is_open() override;
WebContent: Implement the WebDriver concept of current browsing context When we create a WebDriverConnection object, we currently hand it the page client for which it was opened, and perform all actions on that client. However, some WebDriver endpoints change the browsing context (and therefore page client) on which future commands should be executed. For example, the switch-frame endpoint will switch the current browsing context to a frame/iframe context. This patch implements the current browsing context (and current top- level browsing context) concepts. They are initialized to that of the original page. Most of this patch is making sure we execute actions on the correct context.
2024-09-13 17:18:23 -04:00
WebContent: Separately store the WebDriver parent and top-level BCs We are currently trying to access the current parent and top-level browsing contexts from the current BC itself. However, if the current BC is closed, its association to the parent and top-level BCs is lost, and we are no longer able to handle WebDriver endpoints involving those BCs. Instead, let's store the parent and top-level BCs separately, and update them in accordance with the spec.
2024-10-01 13:04:37 -04:00
void set_current_browsing_context(Web::HTML::BrowsingContext&);
WebContent: Implement the WebDriver concept of current browsing context When we create a WebDriverConnection object, we currently hand it the page client for which it was opened, and perform all actions on that client. However, some WebDriver endpoints change the browsing context (and therefore page client) on which future commands should be executed. For example, the switch-frame endpoint will switch the current browsing context to a frame/iframe context. This patch implements the current browsing context (and current top- level browsing context) concepts. They are initialized to that of the original page. Most of this patch is making sure we execute actions on the correct context.
2024-09-13 17:18:23 -04:00
Web::HTML::BrowsingContext& current_browsing_context() { return *m_current_browsing_context; }
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Web::HTML::BrowsingContext> current_parent_browsing_context() { return m_current_parent_browsing_context; }
WebContent: Separately store the WebDriver parent and top-level BCs We are currently trying to access the current parent and top-level browsing contexts from the current BC itself. However, if the current BC is closed, its association to the parent and top-level BCs is lost, and we are no longer able to handle WebDriver endpoints involving those BCs. Instead, let's store the parent and top-level BCs separately, and update them in accordance with the spec.
2024-10-01 13:04:37 -04:00
void set_current_top_level_browsing_context(Web::HTML::BrowsingContext&);
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Web::HTML::BrowsingContext> current_top_level_browsing_context() { return m_current_top_level_browsing_context; }
WebContent: Implement the WebDriver concept of current browsing context When we create a WebDriverConnection object, we currently hand it the page client for which it was opened, and perform all actions on that client. However, some WebDriver endpoints change the browsing context (and therefore page client) on which future commands should be executed. For example, the switch-frame endpoint will switch the current browsing context to a frame/iframe context. This patch implements the current browsing context (and current top- level browsing context) concepts. They are initialized to that of the original page. Most of this patch is making sure we execute actions on the correct context.
2024-09-13 17:18:23 -04:00
ErrorOr<void, Web::WebDriver::Error> ensure_current_browsing_context_is_open();
ErrorOr<void, Web::WebDriver::Error> ensure_current_top_level_browsing_context_is_open();
WebContent+WebDriver: Ensure Get Window Handle checks for closed BCs
2023-03-07 11:29:14 -05:00
LibIPC+Everywhere: Always pass ownership of transferred data to clients This has been a longstanding ergonomic issue with our IPC compiler. Non- trivial types were previously passed by const&. So if we wanted to avoid expensive copies, we would have to const_cast and move the data. We now pass ownership of all transferred data to the client subclasses. This allows us to remove const_cast from these methods, and allows us to avoid some trivial expensive copies that we didn't bother to const_cast.
2025-03-08 12:22:39 -05:00
Web::WebDriver::Response element_click_impl(StringView element_id);
Web::WebDriver::Response element_clear_impl(StringView element_id);
Web::WebDriver::Response element_send_keys_impl(StringView element_id, String const& text);
WebContent+WebDriver: Convert all user prompt handlers to be async Making these async were all actually pretty trivial. This patch does so, and removes the deprecated synchronous user prompt handler.
2024-11-03 09:39:18 -05:00
Web::WebDriver::Response add_cookie_impl(JsonObject const&);
WebContent: Begin handling user prompts asynchronously We have to handle user prompts during the exection of most WebDriver endpoints. Of the ~50 endpoints which call this AO, ~20 are currently currently async and handled here.
2024-11-01 08:20:14 -04:00
LibWeb+WebContent+WebDriver: Allow specifying multiple prompt handlers WebDriver script authors may now provide either: * A user prompt handler configuration to be used for all prompt types. * A set of per-prompt-type user prompt handlers. This also paves the way for interaction with the beforeunload prompt, though we do not yet support that feature in LibWeb. See: https://github.com/w3c/webdriver/commit/43903d0
2025-02-05 11:36:19 -05:00
Web::WebDriver::PromptHandlerConfiguration get_the_prompt_handler(Web::WebDriver::PromptType type) const;
WebContent: Begin handling user prompts asynchronously We have to handle user prompts during the exection of most WebDriver endpoints. Of the ~50 endpoints which call this AO, ~20 are currently currently async and handled here.
2024-11-01 08:20:14 -04:00
void handle_any_user_prompts(Function<void()> on_dialog_closed);
LibWeb+WebContent+WebDriver+UI: Make window min/maximize asynchronous This follows suit of previous changes to never block the WebContent process in WebDriver endpoints.
2024-10-28 23:45:18 -04:00
void maximize_the_window();
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
void iconify_the_window(GC::Ref<GC::Function<void()>>);
void restore_the_window(GC::Ref<GC::Function<void()>>);
void wait_for_visibility_state(GC::Ref<GC::Function<void()>>, Web::HTML::VisibilityState);
WebContent: Don't assume start nodes for finding elements remain valid When timeouts are implemented, the start node used to find elements may not remain valid for the entire duration of the timeout. For example, the active document element may change, or the start node may be removed from the DOM. To handle this, we will need to re-evaluate the start node on each iteration of the find() operation. This patch wraps the steps to do so in a lambda to be executed on each iteration.
2022-11-21 09:51:46 -05:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
using OnNavigationComplete = GC::Ref<GC::Function<void(Web::WebDriver::Response)>>;
WebContent+WebDriver: Asynchronously wait for navigations to complete Similar to commit c2cf65adac78912883996153fb608dafe389b6e0, we should avoid spinning the event loop from the WebContent-side of the WebDriver connection. This can result in deadlocks if another component in LibWeb also spins the event loop. The AO to await navigations has two event loop spinners - waiting for the navigation to complete and for the document to reach the target readiness state. We now use NavigationObserver and DocumentObserver to be notified when these conditions are met. And we use the same async IPC mechanism as script execution to notify the WebDriver process when all conditions are met (or timed out).
2024-10-25 10:28:29 -04:00
void wait_for_navigation_to_complete(OnNavigationComplete);
WebContent: Wait for navigation to complete in WebDriver Implements https://w3c.github.io/webdriver/#dfn-waiting-for-the-navigation-to-complete.
2023-03-08 02:04:17 +03:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
Gfx::IntPoint calculate_absolute_position_of_element(GC::Ref<Web::Geometry::DOMRect> rect);
WebContent: Implement the WebDriver concept of current browsing context When we create a WebDriverConnection object, we currently hand it the page client for which it was opened, and perform all actions on that client. However, some WebDriver endpoints change the browsing context (and therefore page client) on which future commands should be executed. For example, the switch-frame endpoint will switch the current browsing context to a frame/iframe context. This patch implements the current browsing context (and current top- level browsing context) concepts. They are initialized to that of the original page. Most of this patch is making sure we execute actions on the correct context.
2024-09-13 17:18:23 -04:00
Gfx::IntRect calculate_absolute_rect_of_element(Web::DOM::Element const& element);
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
using GetStartNode = GC::Ref<GC::Function<ErrorOr<GC::Ref<Web::DOM::ParentNode>, Web::WebDriver::Error>()>>;
using OnFindComplete = GC::Ref<GC::Function<void(Web::WebDriver::Response)>>;
LibWeb+WebContent+WebDriver: Port WebDriver to String
2025-02-17 13:58:21 -05:00
void find(Web::WebDriver::LocationStrategy, String, GetStartNode, OnFindComplete);
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
WebContent+WebDriver: Move Execute Script to WebContent
2022-11-10 20:55:17 -05:00
struct ScriptArguments {
LibWeb+WebContent+WebDriver: Port WebDriver to String
2025-02-17 13:58:21 -05:00
String script;
LibGC: Rename MarkedVector => RootVector Let's try to make it a bit more clear that this is a Vector of GC roots.
2024-12-26 14:32:52 +01:00
GC::RootVector<JS::Value> arguments;
WebContent+WebDriver: Move Execute Script to WebContent
2022-11-10 20:55:17 -05:00
};
WebContent: Create a temporary execution context to parse WebDriver JSON
2024-09-27 17:42:07 -04:00
ErrorOr<ScriptArguments, Web::WebDriver::Error> extract_the_script_arguments_from_a_request(JS::VM&, JsonValue const& payload);
WebContent: Track the ongoing script execution with an ID Executing scripts via WebDriver has a bit of awkwardness around dealing with user dialogs that open during script execution. When this happens, we must return control back to the client immediately with a null response, while allowing the script to continue executing. When the script completes, we must then ignore its result. We've previously handled this by tracking a boolean for the ongoing script execution, set to true when the script begins and false when it ends (either via normal script completion or the above dialog handling). However, this failed to handle the following scenario, running two scripts in a row: execute_script("alert('hi'); return 1;") execute_script("return 2;") The first script would execute and open a dialog, and thus return a null response to the client while the script continued and the dialog remains open. The second script would "handle any user prompts", which closes the dialog. This would end the execution of the first script. But since we're now executing a script again, the boolean flag is true, and we'd return the result of the first script back to the client. The client would then think this is the result of the second script. So we now track script execution with a simple ID. If a script completes whose execution ID is not the ID of the currently executing script, we drop the result.
2025-02-07 07:13:56 -05:00
void handle_script_response(Web::WebDriver::ExecutionResult, size_t script_execution_id);
LibWeb+WebContent: Handle user prompts that open during script execution If a dialog is opened while a script is executing, we must give control back to the WebDriver client. The script must also continue executing though, so once it completes, we ignore its result.
2024-10-31 20:23:36 -04:00
Browser+WebContent+WebDriver: Move Delete Cookie to WebContent
2022-11-11 11:21:00 -05:00
void delete_cookies(Optional<StringView> const& name = {});
WebContent+WebDriver: Move Execute Script to WebContent
2022-11-10 20:55:17 -05:00
WebContent+WebDriver: Send the parsed capabilities over to WebContent
2022-11-17 16:27:32 -05:00
// https://w3c.github.io/webdriver/#dfn-page-load-strategy
Web::WebDriver::PageLoadStrategy m_page_load_strategy { Web::WebDriver::PageLoadStrategy::Normal };
// https://w3c.github.io/webdriver/#dfn-strict-file-interactability
bool m_strict_file_interactability { false };
WebContent+WebDriver: Move Get/Set Timeouts to WebContent
2022-11-11 14:28:57 -05:00
// https://w3c.github.io/webdriver/#dfn-session-script-timeout
Web::WebDriver::TimeoutsConfiguration m_timeouts_configuration;
WebContent: Implement the WebDriver concept of current browsing context When we create a WebDriverConnection object, we currently hand it the page client for which it was opened, and perform all actions on that client. However, some WebDriver endpoints change the browsing context (and therefore page client) on which future commands should be executed. For example, the switch-frame endpoint will switch the current browsing context to a frame/iframe context. This patch implements the current browsing context (and current top- level browsing context) concepts. They are initialized to that of the original page. Most of this patch is making sure we execute actions on the correct context.
2024-09-13 17:18:23 -04:00
// https://w3c.github.io/webdriver/#dfn-current-browsing-context
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Web::HTML::BrowsingContext> m_current_browsing_context;
LibWeb+WebContent+WebDriver: Implement the Perform Actions endpoint Similar to script execution, this spins the WebDriver process until the action is complete (rather than spinning the WebContent process, which we've seen result in deadlocks).
2024-09-29 09:40:17 -04:00
WebContent: Separately store the WebDriver parent and top-level BCs We are currently trying to access the current parent and top-level browsing contexts from the current BC itself. However, if the current BC is closed, its association to the parent and top-level BCs is lost, and we are no longer able to handle WebDriver endpoints involving those BCs. Instead, let's store the parent and top-level BCs separately, and update them in accordance with the spec.
2024-10-01 13:04:37 -04:00
// https://w3c.github.io/webdriver/#dfn-current-parent-browsing-context
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Web::HTML::BrowsingContext> m_current_parent_browsing_context;
WebContent: Separately store the WebDriver parent and top-level BCs We are currently trying to access the current parent and top-level browsing contexts from the current BC itself. However, if the current BC is closed, its association to the parent and top-level BCs is lost, and we are no longer able to handle WebDriver endpoints involving those BCs. Instead, let's store the parent and top-level BCs separately, and update them in accordance with the spec.
2024-10-01 13:04:37 -04:00
// https://w3c.github.io/webdriver/#dfn-current-top-level-browsing-context
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Web::HTML::BrowsingContext> m_current_top_level_browsing_context;
WebContent: Separately store the WebDriver parent and top-level BCs We are currently trying to access the current parent and top-level browsing contexts from the current BC itself. However, if the current BC is closed, its association to the parent and top-level BCs is lost, and we are no longer able to handle WebDriver endpoints involving those BCs. Instead, let's store the parent and top-level BCs separately, and update them in accordance with the spec.
2024-10-01 13:04:37 -04:00
LibWeb+WebContent+WebDriver+UI: Make window rect updates asynchronous It's currently possible for window size/position updates to hang, as the underlying IPCs are synchronous. This updates the WebDriver endpoint to be async, to unblock the WebContent process while the update is ongoing. The UI process is now responsible for informing WebContent when the update is complete.
2024-10-28 23:37:11 -04:00
size_t m_pending_window_rect_requests { 0 };
WebContent: Track the ongoing script execution with an ID Executing scripts via WebDriver has a bit of awkwardness around dealing with user dialogs that open during script execution. When this happens, we must return control back to the client immediately with a null response, while allowing the script to continue executing. When the script completes, we must then ignore its result. We've previously handled this by tracking a boolean for the ongoing script execution, set to true when the script begins and false when it ends (either via normal script completion or the above dialog handling). However, this failed to handle the following scenario, running two scripts in a row: execute_script("alert('hi'); return 1;") execute_script("return 2;") The first script would execute and open a dialog, and thus return a null response to the client while the script continued and the dialog remains open. The second script would "handle any user prompts", which closes the dialog. This would end the execution of the first script. But since we're now executing a script again, the boolean flag is true, and we'd return the result of the first script back to the client. The client would then think this is the result of the second script. So we now track script execution with a simple ID. If a script completes whose execution ID is not the ID of the currently executing script, we drop the result.
2025-02-07 07:13:56 -05:00
size_t m_script_execution_id_counter { 0 };
Optional<size_t> m_current_script_execution_id;
LibWeb+WebContent+WebDriver+UI: Make window rect updates asynchronous It's currently possible for window size/position updates to hang, as the underlying IPCs are synchronous. This updates the WebDriver endpoint to be async, to unblock the WebContent process while the update is ongoing. The UI process is now responsible for informing WebContent when the update is complete.
2024-10-28 23:37:11 -04:00
WebContent+WebDriver: Make the element locator endpoints asynchronous We currently spin the event loop to wait for the specified element to become available. As we've seen with other endpoints, this can result in dead locks if another web component also spins the event loop. This patch makes the locator implementations asynchronous.
2024-10-30 15:26:04 -04:00
friend class ElementLocator;
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<ElementLocator> m_element_locator;
WebContent+WebDriver: Make the element locator endpoints asynchronous We currently spin the event loop to wait for the specified element to become available. As we've seen with other endpoints, this can result in dead locks if another web component also spins the event loop. This patch makes the locator implementations asynchronous.
2024-10-30 15:26:04 -04:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<JS::Cell> m_action_executor;
WebContent+WebDriver: Asynchronously wait for navigations to complete Similar to commit c2cf65adac78912883996153fb608dafe389b6e0, we should avoid spinning the event loop from the WebContent-side of the WebDriver connection. This can result in deadlocks if another component in LibWeb also spins the event loop. The AO to await navigations has two event loop spinners - waiting for the navigation to complete and for the document to reach the target readiness state. We now use NavigationObserver and DocumentObserver to be notified when these conditions are met. And we use the same async IPC mechanism as script execution to notify the WebDriver process when all conditions are met (or timed out).
2024-10-25 10:28:29 -04:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Web::DOM::DocumentObserver> m_document_observer;
GC::Ptr<Web::HTML::NavigationObserver> m_navigation_observer;
GC::Ptr<Web::WebDriver::HeapTimer> m_navigation_timer;
WebContent: Add a very-empty WebDriver IPC class to WebContent This just sets up the infrastructure for the WebContent process to house WebDriver IPCs, and adds an IPC for WebContent to create the WebDriver connection. The WebDriverConnection class inside WebContent ultimately will contain most of what is currently in WebDriver::Session (so the copyright attributions are copied here as well). The socket created by WebDriver is currently /tmp/browser_webdriver (formatted with some IDs). This will be moved to the /tmp/webdriver folder, as WebDriver will create multiple sockets to communicate with both Browser and WebContent as the IPCs are iteratively moved to WebContent. That path is unveiled here, though it is unused as of this commit.
2022-11-08 10:03:07 -05:00
};
}
Reference in a new issue Copy permalink