Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-31 21:30:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/WebDriver/Client.h

144 lines
7.5 KiB
C
Raw Normal View History

LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
/*
* Copyright (c) 2022, Florent Castelli <florent.castelli@gmail.com>
* Copyright (c) 2022, Linus Groh <linusg@serenityos.org>
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
* Copyright (c) 2022-2024, Tim Flynn <trflynn89@ladybird.org>
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Error.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/NonnullOwnPtr.h>
#include <AK/String.h>
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
#include <AK/Variant.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/Vector.h>
Userland: Rename Core::Object to Core::EventReceiver This is a more precise description of what this class actually does.
2023-08-06 18:09:39 +02:00
#include <LibCore/EventReceiver.h>
LibCore: Move Stream-based sockets into the `Core` namespace
2023-02-08 23:05:44 +01:00
#include <LibCore/Socket.h>
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
#include <LibHTTP/Forward.h>
#include <LibHTTP/HttpRequest.h>
#include <LibWeb/WebDriver/Error.h>
#include <LibWeb/WebDriver/Response.h>
namespace Web::WebDriver {
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
using Parameters = Vector<String>;
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
Userland: Rename Core::Object to Core::EventReceiver This is a more precise description of what this class actually does.
2023-08-06 18:09:39 +02:00
class Client : public Core::EventReceiver {
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
C_OBJECT_ABSTRACT(Client);
public:
virtual ~Client();
// 8. Sessions, https://w3c.github.io/webdriver/#sessions
virtual Response new_session(Parameters parameters, JsonValue payload) = 0;
virtual Response delete_session(Parameters parameters, JsonValue payload) = 0;
virtual Response get_status(Parameters parameters, JsonValue payload) = 0;
// 9. Timeouts, https://w3c.github.io/webdriver/#timeouts
virtual Response get_timeouts(Parameters parameters, JsonValue payload) = 0;
virtual Response set_timeouts(Parameters parameters, JsonValue payload) = 0;
// 10. Navigation, https://w3c.github.io/webdriver/#navigation
virtual Response navigate_to(Parameters parameters, JsonValue payload) = 0;
virtual Response get_current_url(Parameters parameters, JsonValue payload) = 0;
virtual Response back(Parameters parameters, JsonValue payload) = 0;
virtual Response forward(Parameters parameters, JsonValue payload) = 0;
virtual Response refresh(Parameters parameters, JsonValue payload) = 0;
virtual Response get_title(Parameters parameters, JsonValue payload) = 0;
// 11. Contexts, https://w3c.github.io/webdriver/#contexts
virtual Response get_window_handle(Parameters parameters, JsonValue payload) = 0;
virtual Response close_window(Parameters parameters, JsonValue payload) = 0;
LibWeb+WebContent+WebDriver: Add WebDriver endpoint to open new window
2023-03-14 14:09:50 +03:00
virtual Response new_window(Parameters parameters, JsonValue payload) = 0;
WebContent+WebDriver: Implement `POST /session/{id}/window` endpoint
2022-11-24 20:32:53 -06:00
virtual Response switch_to_window(Parameters parameters, JsonValue payload) = 0;
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
virtual Response get_window_handles(Parameters parameters, JsonValue payload) = 0;
virtual Response get_window_rect(Parameters parameters, JsonValue payload) = 0;
virtual Response set_window_rect(Parameters parameters, JsonValue payload) = 0;
virtual Response maximize_window(Parameters parameters, JsonValue payload) = 0;
virtual Response minimize_window(Parameters parameters, JsonValue payload) = 0;
virtual Response fullscreen_window(Parameters parameters, JsonValue payload) = 0;
WebDriver: Add Routes, IPC definitions, and boilerplates Added the following Routes, IPC definitions, and boilerplates for the missing endpoints: - Switch To Frame - Switch To Parent Frame - Element Clear - Element Send Keys
2024-09-07 12:41:54 -07:00
virtual Response switch_to_frame(Parameters parameters, JsonValue payload) = 0;
virtual Response switch_to_parent_frame(Parameters parameters, JsonValue payload) = 0;
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
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
// Extension: https://html.spec.whatwg.org/multipage/interaction.html#user-activation-user-agent-automation
virtual Response consume_user_activation(Parameters parameters, JsonValue payload) = 0;
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
// 12. Elements, https://w3c.github.io/webdriver/#elements
virtual Response find_element(Parameters parameters, JsonValue payload) = 0;
virtual Response find_elements(Parameters parameters, JsonValue payload) = 0;
virtual Response find_element_from_element(Parameters parameters, JsonValue payload) = 0;
virtual Response find_elements_from_element(Parameters parameters, JsonValue payload) = 0;
LibWeb+WebContent+WebDriver: Implement Find Element From Shadow Root
2022-11-14 19:48:48 -05:00
virtual Response find_element_from_shadow_root(Parameters parameters, JsonValue payload) = 0;
LibWeb+WebContent+WebDriver: Implement Find Elements From Shadow Root
2022-11-14 19:54:17 -05:00
virtual Response find_elements_from_shadow_root(Parameters parameters, JsonValue payload) = 0;
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 Response get_active_element(Parameters parameters, JsonValue payload) = 0;
LibWeb+WebContent+WebDriver: Implement Get Element Shadow Root
2022-11-14 19:27:11 -05:00
virtual Response get_element_shadow_root(Parameters parameters, JsonValue payload) = 0;
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
virtual Response is_element_selected(Parameters parameters, JsonValue payload) = 0;
virtual Response get_element_attribute(Parameters parameters, JsonValue payload) = 0;
virtual Response get_element_property(Parameters parameters, JsonValue payload) = 0;
virtual Response get_element_css_value(Parameters parameters, JsonValue payload) = 0;
virtual Response get_element_text(Parameters parameters, JsonValue payload) = 0;
virtual Response get_element_tag_name(Parameters parameters, JsonValue payload) = 0;
virtual Response get_element_rect(Parameters parameters, JsonValue payload) = 0;
virtual Response is_element_enabled(Parameters parameters, JsonValue payload) = 0;
WebDriver: Add computedrole endpoint
2023-01-15 10:26:08 -06:00
virtual Response get_computed_role(Parameters parameters, JsonValue payload) = 0;
WebDriver: Add computedlabel endpoint
2023-02-19 11:36:08 -06:00
virtual Response get_computed_label(Parameters parameters, JsonValue payload) = 0;
WebDriver+LibWeb: Rename "click" to "element_click" This matches the name used in the spec, and is unambiguous.
2023-01-26 14:11:54 +00:00
virtual Response element_click(Parameters parameters, JsonValue payload) = 0;
WebDriver: Add Routes, IPC definitions, and boilerplates Added the following Routes, IPC definitions, and boilerplates for the missing endpoints: - Switch To Frame - Switch To Parent Frame - Element Clear - Element Send Keys
2024-09-07 12:41:54 -07:00
virtual Response element_clear(Parameters parameters, JsonValue payload) = 0;
virtual Response element_send_keys(Parameters parameters, JsonValue payload) = 0;
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
LibWeb: Fix typo in WebDriver section comment
2022-11-16 07:15:09 -05:00
// 13. Document, https://w3c.github.io/webdriver/#document
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
virtual Response get_source(Parameters parameters, JsonValue payload) = 0;
virtual Response execute_script(Parameters parameters, JsonValue payload) = 0;
virtual Response execute_async_script(Parameters parameters, JsonValue payload) = 0;
// 14. Cookies, https://w3c.github.io/webdriver/#cookies
virtual Response get_all_cookies(Parameters parameters, JsonValue payload) = 0;
virtual Response get_named_cookie(Parameters parameters, JsonValue payload) = 0;
virtual Response add_cookie(Parameters parameters, JsonValue payload) = 0;
virtual Response delete_cookie(Parameters parameters, JsonValue payload) = 0;
virtual Response delete_all_cookies(Parameters parameters, JsonValue payload) = 0;
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
// 15. Actions, https://w3c.github.io/webdriver/#actions
WebDriver: Add boilerplate for endpoint 15.7 Perform Actions Following the structure of the ReleaseActions endpoints, define analogous classes and methods for PerformActions
2024-09-02 14:41:24 -04:00
virtual Response perform_actions(Parameters parameters, JsonValue payload) = 0;
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 Response release_actions(Parameters parameters, JsonValue payload) = 0;
LibWeb+WebContent+WebDriver: Implement Dismiss Alert
2022-11-16 07:15:57 -05:00
// 16. User prompts, https://w3c.github.io/webdriver/#user-prompts
virtual Response dismiss_alert(Parameters parameters, JsonValue payload) = 0;
LibWeb+WebContent+WebDriver: Implement Accept Alert
2022-11-16 07:24:22 -05:00
virtual Response accept_alert(Parameters parameters, JsonValue payload) = 0;
LibWeb+WebContent+WebDriver: Implement Get Alert Text
2022-11-16 08:26:48 -05:00
virtual Response get_alert_text(Parameters parameters, JsonValue payload) = 0;
LibWeb+LibWebView+WebContent+WebDriver: Implement Send Alert Text
2022-11-16 08:57:05 -05:00
virtual Response send_alert_text(Parameters parameters, JsonValue payload) = 0;
LibWeb+WebContent+WebDriver: Implement Dismiss Alert
2022-11-16 07:15:57 -05:00
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
// 17. Screen capture, https://w3c.github.io/webdriver/#screen-capture
virtual Response take_screenshot(Parameters parameters, JsonValue payload) = 0;
virtual Response take_element_screenshot(Parameters parameters, JsonValue payload) = 0;
WebDriver: Implement stub for /session/{id}/print
2022-11-27 00:30:03 +01:00
// 18. Print, https://w3c.github.io/webdriver/#print
virtual Response print_page(Parameters parameters, JsonValue payload) = 0;
WebDriver: Stop using the ancient Core::EventReceiver parent/child API Before this change, clients were kept alive by making them children of the TCPServer object. This ownership model is going away (and this was the only remaining use of it!) so let's just put the clients in a hash table instead.
2025-08-10 16:34:51 +02:00
Function<void()> on_death;
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
protected:
WebDriver: Stop using the ancient Core::EventReceiver parent/child API Before this change, clients were kept alive by making them children of the TCPServer object. This ownership model is going away (and this was the only remaining use of it!) so let's just put the clients in a hash table instead.
2025-08-10 16:34:51 +02:00
explicit Client(NonnullOwnPtr<Core::BufferedTCPSocket>);
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
private:
LibHTTP+WebDriver+WebServer: Return error from HTTP request parser
2023-03-23 02:52:06 +03:00
using WrappedError = Variant<AK::Error, HTTP::HttpRequest::ParseError, WebDriver::Error>;
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
void die();
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
ErrorOr<void, WrappedError> on_ready_to_read();
LibWeb: Defer handling of WebDriver endpoint invocations We can currently crash on WebDriver session shutdown when we receive a Delete Session command. This destroys the WebDriver client while we are inside the client's socket's on_ready_to_read callback. This is not allowed by AK::Function. To avoid this, we now only read data from the socket in the callback. We then defer handling the message to break out of the callback.
2024-10-27 14:57:00 -04:00
static ErrorOr<JsonValue, WrappedError> read_body_as_json(HTTP::HttpRequest const&);
ErrorOr<void, WrappedError> handle_request(HTTP::HttpRequest const&, JsonValue body);
void handle_error(HTTP::HttpRequest const&, WrappedError const&);
ErrorOr<void, WrappedError> send_success_response(HTTP::HttpRequest const&, JsonValue result);
ErrorOr<void, WrappedError> send_error_response(HTTP::HttpRequest const&, Error const& error);
static void log_response(HTTP::HttpRequest const&, unsigned code);
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
LibCore: Move Stream-based sockets into the `Core` namespace
2023-02-08 23:05:44 +01:00
NonnullOwnPtr<Core::BufferedTCPSocket> m_socket;
LibWeb/WebDriver: Wait for more data to arrive if request is incomplete Currently significant portion of requests coming to WebDriver server fails with error while parsing json body because requests are parsed when they are not complete yet. This change solves this by waiting for more data to arrive if HTTP request parser found that there is not enough data yet to parse the whole request. In the future we would probably want to move this logic to LibHTTP because this problem is relevant for any HTTP server.
2023-03-23 03:14:17 +03:00
StringBuilder m_remaining_request;
LibWeb: Re-implement WebDriver endpoint handling within Web::WebDriver This moves communication and route matching for WebDriver endpoints into LibWeb. This is to reduce the amount of duplication required to create a WebDriver implementation for Ladybird. In doing so, this introduces some cleanup of WebDriver handling. Routes are now a compile-time array, and matching a route is nearly free of allocations (we still allocate a Vector for parsed parameters). This implementation also makes heavier use of TRY semantics to propagate errors into one handler.
2022-11-12 23:23:37 -05:00
};
}
Reference in a new issue Copy permalink