mirrors/ladybird
0
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-08-06 16:19:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

LibWebView+LibWeb: Remove ResourceLoader and WebSocket adapters

Browse source 
These were used to provide a layer of abstraction between ResourceLoader
and the networking backend. Now that we only have RequestServer, we can
remove these adapters to make the code a bit easier to follow.
This commit is contained in:
Timothy Flynn 2024-10-07 16:07:48 -04:00 • committed by Andreas Kling
commit 00487a7b25
Notes: github-actions[bot] 2024-10-08 04:53:41 +00:00
12 changed files with 48 additions and 463 deletions
Download patch file Download diff file Expand all files Collapse all files

11
Ladybird/WebContent/main.cpp
View file

@ -28,7 +28,6 @@
#include <LibWeb/PermissionsPolicy/AutoplayAllowlist.h> #include <LibWeb/PermissionsPolicy/AutoplayAllowlist.h>
#include <LibWeb/Platform/AudioCodecPluginAgnostic.h> #include <LibWeb/Platform/AudioCodecPluginAgnostic.h>
#include <LibWeb/Platform/EventLoopPluginSerenity.h> #include <LibWeb/Platform/EventLoopPluginSerenity.h>
#include <LibWebView/RequestServerAdapter.h>
#include <WebContent/ConnectionFromClient.h> #include <WebContent/ConnectionFromClient.h>
#include <WebContent/PageClient.h> #include <WebContent/PageClient.h>
#include <WebContent/WebDriverConnection.h> #include <WebContent/WebDriverConnection.h>
@ -48,7 +47,7 @@
static ErrorOr<void> load_content_filters(StringView config_path); static ErrorOr<void> load_content_filters(StringView config_path);
static ErrorOr<void> load_autoplay_allowlist(StringView config_path); static ErrorOr<void> load_autoplay_allowlist(StringView config_path);
static ErrorOr<void> initialize_lagom_networking(int request_server_socket); static ErrorOr<void> initialize_resource_loader(int request_server_socket);
static ErrorOr<void> initialize_image_decoder(int image_decoder_socket); static ErrorOr<void> initialize_image_decoder(int image_decoder_socket);
static ErrorOr<void> reinitialize_image_decoder(IPC::File const& image_decoder_socket); static ErrorOr<void> reinitialize_image_decoder(IPC::File const& image_decoder_socket);
@ -163,7 +162,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
} }
#endif #endif
TRY(initialize_lagom_networking(request_server_socket)); TRY(initialize_resource_loader(request_server_socket));
TRY(initialize_image_decoder(image_decoder_socket)); TRY(initialize_image_decoder(image_decoder_socket));
Web::HTML::Window::set_internals_object_exposed(expose_internals_object); Web::HTML::Window::set_internals_object_exposed(expose_internals_object);
@ -248,14 +247,14 @@ static ErrorOr<void> load_autoplay_allowlist(StringView config_path)
return {}; return {};
} }
ErrorOr<void> initialize_lagom_networking(int request_server_socket) ErrorOr<void> initialize_resource_loader(int request_server_socket)
{ {
auto socket = TRY(Core::LocalSocket::adopt_fd(request_server_socket)); auto socket = TRY(Core::LocalSocket::adopt_fd(request_server_socket));
TRY(socket->set_blocking(true)); TRY(socket->set_blocking(true));
auto new_client = TRY(try_make_ref_counted<Requests::RequestClient>(move(socket))); auto request_client = TRY(try_make_ref_counted<Requests::RequestClient>(move(socket)));
Web::ResourceLoader::initialize(move(request_client));
Web::ResourceLoader::initialize(TRY(WebView::RequestServerAdapter::try_create(move(new_client))));
return {}; return {};
} }

13
Ladybird/WebWorker/main.cpp
View file

@ -22,8 +22,6 @@
#include <LibWeb/Platform/EventLoopPlugin.h> #include <LibWeb/Platform/EventLoopPlugin.h>
#include <LibWeb/Platform/EventLoopPluginSerenity.h> #include <LibWeb/Platform/EventLoopPluginSerenity.h>
#include <LibWeb/WebSockets/WebSocket.h> #include <LibWeb/WebSockets/WebSocket.h>
#include <LibWebView/RequestServerAdapter.h>
#include <LibWebView/WebSocketClientAdapter.h>
#include <WebWorker/ConnectionFromClient.h> #include <WebWorker/ConnectionFromClient.h>
#if defined(HAVE_QT) #if defined(HAVE_QT)
@ -31,7 +29,7 @@
# include <QCoreApplication> # include <QCoreApplication>
#endif #endif
static ErrorOr<void> initialize_lagom_networking(int request_server_socket); static ErrorOr<void> initialize_resource_loader(int request_server_socket);
ErrorOr<int> serenity_main(Main::Arguments arguments) ErrorOr<int> serenity_main(Main::Arguments arguments)
{ {
@ -64,7 +62,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
Web::Platform::FontPlugin::install(*new Ladybird::FontPlugin(false)); Web::Platform::FontPlugin::install(*new Ladybird::FontPlugin(false));
TRY(initialize_lagom_networking(request_server_socket)); TRY(initialize_resource_loader(request_server_socket));
TRY(Web::Bindings::initialize_main_thread_vm(Web::HTML::EventLoop::Type::Worker)); TRY(Web::Bindings::initialize_main_thread_vm(Web::HTML::EventLoop::Type::Worker));
@ -73,14 +71,13 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
return event_loop.exec(); return event_loop.exec();
} }
static ErrorOr<void> initialize_lagom_networking(int request_server_socket) static ErrorOr<void> initialize_resource_loader(int request_server_socket)
{ {
auto socket = TRY(Core::LocalSocket::adopt_fd(request_server_socket)); auto socket = TRY(Core::LocalSocket::adopt_fd(request_server_socket));
TRY(socket->set_blocking(true)); TRY(socket->set_blocking(true));
auto new_client = TRY(try_make_ref_counted<Requests::RequestClient>(move(socket))); auto request_client = TRY(try_make_ref_counted<Requests::RequestClient>(move(socket)));
Web::ResourceLoader::initialize(move(request_client));
Web::ResourceLoader::initialize(TRY(WebView::RequestServerAdapter::try_create(move(new_client))));
return {}; return {};
} }

2
Meta/gn/secondary/Userland/Libraries/LibWebView/BUILD.gn
View file

@ -152,14 +152,12 @@ shared_library("LibWebView") {
"Process.cpp", "Process.cpp",
"ProcessHandle.cpp", "ProcessHandle.cpp",
"ProcessManager.cpp", "ProcessManager.cpp",
"RequestServerAdapter.cpp",
"SearchEngine.cpp", "SearchEngine.cpp",
"SourceHighlighter.cpp", "SourceHighlighter.cpp",
"URL.cpp", "URL.cpp",
"UserAgent.cpp", "UserAgent.cpp",
"ViewImplementation.cpp", "ViewImplementation.cpp",
"WebContentClient.cpp", "WebContentClient.cpp",
"WebSocketClientAdapter.cpp",
] ]
sources += get_target_outputs(":WebContentClientEndpoint") + sources += get_target_outputs(":WebContentClientEndpoint") +
get_target_outputs(":WebContentServerEndpoint") + get_target_outputs(":WebContentServerEndpoint") +

38
Userland/Libraries/LibWeb/Loader/ResourceLoader.cpp
View file

@ -8,9 +8,10 @@
#include <AK/Debug.h> #include <AK/Debug.h>
#include <LibCore/DateTime.h> #include <LibCore/DateTime.h>
#include <LibCore/Directory.h> #include <LibCore/Directory.h>
#include <LibCore/ElapsedTimer.h>
#include <LibCore/MimeData.h> #include <LibCore/MimeData.h>
#include <LibCore/Resource.h> #include <LibCore/Resource.h>
#include <LibRequests/Request.h>
#include <LibRequests/RequestClient.h>
#include <LibWeb/Cookie/Cookie.h> #include <LibWeb/Cookie/Cookie.h>
#include <LibWeb/Cookie/ParsedCookie.h> #include <LibWeb/Cookie/ParsedCookie.h>
#include <LibWeb/Fetch/Infrastructure/URL.h> #include <LibWeb/Fetch/Infrastructure/URL.h>
@ -20,25 +21,17 @@
#include <LibWeb/Loader/ProxyMappings.h> #include <LibWeb/Loader/ProxyMappings.h>
#include <LibWeb/Loader/Resource.h> #include <LibWeb/Loader/Resource.h>
#include <LibWeb/Loader/ResourceLoader.h> #include <LibWeb/Loader/ResourceLoader.h>
#include <LibWeb/Page/Page.h>
#include <LibWeb/Platform/EventLoopPlugin.h> #include <LibWeb/Platform/EventLoopPlugin.h>
#include <LibWeb/Platform/Timer.h> #include <LibWeb/Platform/Timer.h>
namespace Web { namespace Web {
ResourceLoaderConnectorRequest::ResourceLoaderConnectorRequest() = default;
ResourceLoaderConnectorRequest::~ResourceLoaderConnectorRequest() = default;
ResourceLoaderConnector::ResourceLoaderConnector() = default;
ResourceLoaderConnector::~ResourceLoaderConnector() = default;
static RefPtr<ResourceLoader> s_resource_loader; static RefPtr<ResourceLoader> s_resource_loader;
void ResourceLoader::initialize(RefPtr<ResourceLoaderConnector> connector) void ResourceLoader::initialize(NonnullRefPtr<Requests::RequestClient> request_client)
{ {
if (connector) s_resource_loader = adopt_ref(*new ResourceLoader(move(request_client)));
s_resource_loader = ResourceLoader::try_create(connector.release_nonnull()).release_value_but_fixme_should_propagate_errors();
} }
ResourceLoader& ResourceLoader::the() ResourceLoader& ResourceLoader::the()
@ -50,13 +43,8 @@ ResourceLoader& ResourceLoader::the()
return *s_resource_loader; return *s_resource_loader;
} }
ErrorOr<NonnullRefPtr<ResourceLoader>> ResourceLoader::try_create(NonnullRefPtr<ResourceLoaderConnector> connector) ResourceLoader::ResourceLoader(NonnullRefPtr<Requests::RequestClient> request_client)
{ : m_request_client(move(request_client))
return adopt_nonnull_ref_or_enomem(new (nothrow) ResourceLoader(move(connector)));
}
ResourceLoader::ResourceLoader(NonnullRefPtr<ResourceLoaderConnector> connector)
: m_connector(move(connector))
, m_user_agent(MUST(String::from_utf8(default_user_agent))) , m_user_agent(MUST(String::from_utf8(default_user_agent)))
, m_platform(MUST(String::from_utf8(default_platform))) , m_platform(MUST(String::from_utf8(default_platform)))
, m_preferred_languages({ "en-US"_string }) , m_preferred_languages({ "en-US"_string })
@ -74,7 +62,7 @@ void ResourceLoader::prefetch_dns(URL::URL const& url)
return; return;
} }
m_connector->prefetch_dns(url); m_request_client->ensure_connection(url, RequestServer::CacheLevel::ResolveOnly);
} }
void ResourceLoader::preconnect(URL::URL const& url) void ResourceLoader::preconnect(URL::URL const& url)
@ -87,7 +75,7 @@ void ResourceLoader::preconnect(URL::URL const& url)
return; return;
} }
m_connector->preconnect(url); m_request_client->ensure_connection(url, RequestServer::CacheLevel::CreateConnection);
} }
static HashMap<LoadRequest, NonnullRefPtr<Resource>> s_resource_cache; static HashMap<LoadRequest, NonnullRefPtr<Resource>> s_resource_cache;
@ -487,7 +475,7 @@ void ResourceLoader::load_unbuffered(LoadRequest& request, OnHeadersReceived on_
protocol_request->set_unbuffered_request_callbacks(move(protocol_headers_received), move(protocol_data_received), move(protocol_complete)); protocol_request->set_unbuffered_request_callbacks(move(protocol_headers_received), move(protocol_data_received), move(protocol_complete));
} }
RefPtr<ResourceLoaderConnectorRequest> ResourceLoader::start_network_request(LoadRequest const& request) RefPtr<Requests::Request> ResourceLoader::start_network_request(LoadRequest const& request)
{ {
auto proxy = ProxyMappings::the().proxy_for_url(request.url()); auto proxy = ProxyMappings::the().proxy_for_url(request.url());
@ -500,13 +488,13 @@ RefPtr<ResourceLoaderConnectorRequest> ResourceLoader::start_network_request(Loa
if (!headers.contains("User-Agent")) if (!headers.contains("User-Agent"))
headers.set("User-Agent", m_user_agent.to_byte_string()); headers.set("User-Agent", m_user_agent.to_byte_string());
auto protocol_request = m_connector->start_request(request.method(), request.url(), headers, request.body(), proxy); auto protocol_request = m_request_client->start_request(request.method(), request.url(), headers, request.body(), proxy);
if (!protocol_request) { if (!protocol_request) {
log_failure(request, "Failed to initiate load"sv); log_failure(request, "Failed to initiate load"sv);
return nullptr; return nullptr;
} }
protocol_request->on_certificate_requested = []() -> ResourceLoaderConnectorRequest::CertificateAndKey { protocol_request->on_certificate_requested = []() -> Requests::Request::CertificateAndKey {
return {}; return {};
}; };
@ -535,7 +523,7 @@ void ResourceLoader::handle_network_response_headers(LoadRequest const& request,
} }
} }
void ResourceLoader::finish_network_request(NonnullRefPtr<ResourceLoaderConnectorRequest> const& protocol_request) void ResourceLoader::finish_network_request(NonnullRefPtr<Requests::Request> const& protocol_request)
{ {
--m_pending_loads; --m_pending_loads;
if (on_load_counter_change) if (on_load_counter_change)

66
Userland/Libraries/LibWeb/Loader/ResourceLoader.h
View file

@ -9,66 +9,20 @@
#include <AK/ByteString.h> #include <AK/ByteString.h>
#include <AK/Function.h> #include <AK/Function.h>
#include <AK/HashMap.h> #include <AK/HashTable.h>
#include <LibCore/EventReceiver.h> #include <LibCore/EventReceiver.h>
#include <LibCore/Proxy.h>
#include <LibJS/SafeFunction.h> #include <LibJS/SafeFunction.h>
#include <LibRequests/Request.h> #include <LibRequests/Forward.h>
#include <LibURL/URL.h> #include <LibURL/URL.h>
#include <LibWeb/Loader/Resource.h> #include <LibWeb/Loader/Resource.h>
#include <LibWeb/Loader/UserAgent.h> #include <LibWeb/Loader/UserAgent.h>
#include <LibWeb/Page/Page.h>
namespace Web { namespace Web {
namespace WebSockets {
class WebSocketClientSocket;
}
class ResourceLoaderConnectorRequest : public RefCounted<ResourceLoaderConnectorRequest> {
public:
virtual ~ResourceLoaderConnectorRequest();
struct CertificateAndKey {
ByteString certificate;
ByteString key;
};
// Configure the request such that the entirety of the response data is buffered. The callback receives that data and
// the response headers all at once. Using this method is mutually exclusive with `set_unbuffered_data_received_callback`.
virtual void set_buffered_request_finished_callback(Requests::Request::BufferedRequestFinished) = 0;
// Configure the request such that the response data is provided unbuffered as it is received. Using this method is
// mutually exclusive with `set_buffered_request_finished_callback`.
virtual void set_unbuffered_request_callbacks(Requests::Request::HeadersReceived, Requests::Request::DataReceived, Requests::Request::RequestFinished) = 0;
virtual bool stop() = 0;
Function<void(Optional<u64> total_size, u64 downloaded_size)> on_progress;
Function<CertificateAndKey()> on_certificate_requested;
protected:
explicit ResourceLoaderConnectorRequest();
};
class ResourceLoaderConnector : public RefCounted<ResourceLoaderConnector> {
public:
virtual ~ResourceLoaderConnector();
virtual void prefetch_dns(URL::URL const&) = 0;
virtual void preconnect(URL::URL const&) = 0;
virtual RefPtr<ResourceLoaderConnectorRequest> start_request(ByteString const& method, URL::URL const&, HTTP::HeaderMap const& request_headers = {}, ReadonlyBytes request_body = {}, Core::ProxyData const& = {}) = 0;
virtual RefPtr<Web::WebSockets::WebSocketClientSocket> websocket_connect(const URL::URL&, ByteString const& origin, Vector<ByteString> const& protocols) = 0;
protected:
explicit ResourceLoaderConnector();
};
class ResourceLoader : public Core::EventReceiver { class ResourceLoader : public Core::EventReceiver {
C_OBJECT_ABSTRACT(ResourceLoader) C_OBJECT_ABSTRACT(ResourceLoader)
public: public:
static void initialize(RefPtr<ResourceLoaderConnector>); static void initialize(NonnullRefPtr<Requests::RequestClient>);
static ResourceLoader& the(); static ResourceLoader& the();
RefPtr<Resource> load_resource(Resource::Type, LoadRequest&); RefPtr<Resource> load_resource(Resource::Type, LoadRequest&);
@ -85,7 +39,7 @@ public:
void load_unbuffered(LoadRequest&, OnHeadersReceived, OnDataReceived, OnComplete); void load_unbuffered(LoadRequest&, OnHeadersReceived, OnDataReceived, OnComplete);
ResourceLoaderConnector& connector() { return *m_connector; } Requests::RequestClient& request_client() { return *m_request_client; }
void prefetch_dns(URL::URL const&); void prefetch_dns(URL::URL const&);
void preconnect(URL::URL const&); void preconnect(URL::URL const&);
@ -121,17 +75,17 @@ public:
void evict_from_cache(LoadRequest const&); void evict_from_cache(LoadRequest const&);
private: private:
ResourceLoader(NonnullRefPtr<ResourceLoaderConnector>); explicit ResourceLoader(NonnullRefPtr<Requests::RequestClient>);
static ErrorOr<NonnullRefPtr<ResourceLoader>> try_create(NonnullRefPtr<ResourceLoaderConnector>);
RefPtr<ResourceLoaderConnectorRequest> start_network_request(LoadRequest const&); RefPtr<Requests::Request> start_network_request(LoadRequest const&);
void handle_network_response_headers(LoadRequest const&, HTTP::HeaderMap const&); void handle_network_response_headers(LoadRequest const&, HTTP::HeaderMap const&);
void finish_network_request(NonnullRefPtr<ResourceLoaderConnectorRequest> const&); void finish_network_request(NonnullRefPtr<Requests::Request> const&);
int m_pending_loads { 0 }; int m_pending_loads { 0 };
HashTable<NonnullRefPtr<ResourceLoaderConnectorRequest>> m_active_requests; NonnullRefPtr<Requests::RequestClient> m_request_client;
NonnullRefPtr<ResourceLoaderConnector> m_connector; HashTable<NonnullRefPtr<Requests::Request>> m_active_requests;
String m_user_agent; String m_user_agent;
String m_platform; String m_platform;
Vector<String> m_preferred_languages = { "en"_string }; Vector<String> m_preferred_languages = { "en"_string };

22
Userland/Libraries/LibWeb/WebSockets/WebSocket.cpp
View file

@ -8,6 +8,7 @@
#include <AK/QuickSort.h> #include <AK/QuickSort.h>
#include <LibJS/Runtime/ArrayBuffer.h> #include <LibJS/Runtime/ArrayBuffer.h>
#include <LibJS/Runtime/FunctionObject.h> #include <LibJS/Runtime/FunctionObject.h>
#include <LibRequests/RequestClient.h>
#include <LibURL/Origin.h> #include <LibURL/Origin.h>
#include <LibWeb/Bindings/WebSocketPrototype.h> #include <LibWeb/Bindings/WebSocketPrototype.h>
#include <LibWeb/DOM/Document.h> #include <LibWeb/DOM/Document.h>
@ -32,8 +33,6 @@ namespace Web::WebSockets {
JS_DEFINE_ALLOCATOR(WebSocket); JS_DEFINE_ALLOCATOR(WebSocket);
WebSocketClientSocket::~WebSocketClientSocket() = default;
// https://websockets.spec.whatwg.org/#dom-websocket-websocket // https://websockets.spec.whatwg.org/#dom-websocket-websocket
WebIDL::ExceptionOr<JS::NonnullGCPtr<WebSocket>> WebSocket::construct_impl(JS::Realm& realm, String const& url, Optional<Variant<String, Vector<String>>> const& protocols) WebIDL::ExceptionOr<JS::NonnullGCPtr<WebSocket>> WebSocket::construct_impl(JS::Realm& realm, String const& url, Optional<Variant<String, Vector<String>>> const& protocols)
{ {
@ -131,7 +130,8 @@ ErrorOr<void> WebSocket::establish_web_socket_connection(URL::URL& url_record, V
for (auto const& protocol : protocols) for (auto const& protocol : protocols)
TRY(protcol_byte_strings.try_append(protocol.to_byte_string())); TRY(protcol_byte_strings.try_append(protocol.to_byte_string()));
m_websocket = ResourceLoader::the().connector().websocket_connect(url_record, origin_string, protcol_byte_strings); m_websocket = ResourceLoader::the().request_client().websocket_connect(url_record, origin_string, protcol_byte_strings);
m_websocket->on_open = [weak_this = make_weak_ptr<WebSocket>()] { m_websocket->on_open = [weak_this = make_weak_ptr<WebSocket>()] {
if (!weak_this) if (!weak_this)
return; return;
@ -161,11 +161,11 @@ ErrorOr<void> WebSocket::establish_web_socket_connection(URL::URL& url_record, V
} }
// https://websockets.spec.whatwg.org/#dom-websocket-readystate // https://websockets.spec.whatwg.org/#dom-websocket-readystate
WebSocket::ReadyState WebSocket::ready_state() const Requests::WebSocket::ReadyState WebSocket::ready_state() const
{ {
if (!m_websocket) if (m_websocket)
return WebSocket::ReadyState::Closed; return m_websocket->ready_state();
return const_cast<WebSocketClientSocket&>(*m_websocket).ready_state(); return Requests::WebSocket::ReadyState::Closed;
} }
// https://websockets.spec.whatwg.org/#dom-websocket-extensions // https://websockets.spec.whatwg.org/#dom-websocket-extensions
@ -202,7 +202,7 @@ WebIDL::ExceptionOr<void> WebSocket::close(Optional<u16> code, Optional<String>
// 3. Run the first matching steps from the following list: // 3. Run the first matching steps from the following list:
auto state = ready_state(); auto state = ready_state();
// -> If this's ready state is CLOSING (2) or CLOSED (3) // -> If this's ready state is CLOSING (2) or CLOSED (3)
if (state == WebSocket::ReadyState::Closing || state == WebSocket::ReadyState::Closed) if (state == Requests::WebSocket::ReadyState::Closing || state == Requests::WebSocket::ReadyState::Closed)
return {}; return {};
// -> If the WebSocket connection is not yet established [WSP] // -> If the WebSocket connection is not yet established [WSP]
// -> If the WebSocket closing handshake has not yet been started [WSP] // -> If the WebSocket closing handshake has not yet been started [WSP]
@ -217,9 +217,9 @@ WebIDL::ExceptionOr<void> WebSocket::close(Optional<u16> code, Optional<String>
WebIDL::ExceptionOr<void> WebSocket::send(Variant<JS::Handle<WebIDL::BufferSource>, JS::Handle<FileAPI::Blob>, String> const& data) WebIDL::ExceptionOr<void> WebSocket::send(Variant<JS::Handle<WebIDL::BufferSource>, JS::Handle<FileAPI::Blob>, String> const& data)
{ {
auto state = ready_state(); auto state = ready_state();
if (state == WebSocket::ReadyState::Connecting) if (state == Requests::WebSocket::ReadyState::Connecting)
return WebIDL::InvalidStateError::create(realm(), "Websocket is still CONNECTING"_fly_string); return WebIDL::InvalidStateError::create(realm(), "Websocket is still CONNECTING"_fly_string);
if (state == WebSocket::ReadyState::Open) { if (state == Requests::WebSocket::ReadyState::Open) {
TRY_OR_THROW_OOM(vm(), TRY_OR_THROW_OOM(vm(),
data.visit( data.visit(
[this](String const& string) -> ErrorOr<void> { [this](String const& string) -> ErrorOr<void> {
@ -274,7 +274,7 @@ void WebSocket::on_close(u16 code, String reason, bool was_clean)
// https://websockets.spec.whatwg.org/#feedback-from-the-protocol // https://websockets.spec.whatwg.org/#feedback-from-the-protocol
void WebSocket::on_message(ByteBuffer message, bool is_text) void WebSocket::on_message(ByteBuffer message, bool is_text)
{ {
if (m_websocket->ready_state() != WebSocket::ReadyState::Open) if (m_websocket->ready_state() != Requests::WebSocket::ReadyState::Open)
return; return;
if (is_text) { if (is_text) {
auto text_message = ByteString(ReadonlyBytes(message)); auto text_message = ByteString(ReadonlyBytes(message));

53
Userland/Libraries/LibWeb/WebSockets/WebSocket.h
View file

@ -9,6 +9,8 @@
#include <AK/ByteBuffer.h> #include <AK/ByteBuffer.h>
#include <LibCore/EventReceiver.h> #include <LibCore/EventReceiver.h>
#include <LibRequests/Forward.h>
#include <LibRequests/WebSocket.h>
#include <LibURL/URL.h> #include <LibURL/URL.h>
#include <LibWeb/Bindings/PlatformObject.h> #include <LibWeb/Bindings/PlatformObject.h>
#include <LibWeb/DOM/EventTarget.h> #include <LibWeb/DOM/EventTarget.h>
@ -24,21 +26,11 @@
namespace Web::WebSockets { namespace Web::WebSockets {
class WebSocketClientSocket;
class WebSocketClientManager;
class WebSocket final : public DOM::EventTarget { class WebSocket final : public DOM::EventTarget {
WEB_PLATFORM_OBJECT(WebSocket, DOM::EventTarget); WEB_PLATFORM_OBJECT(WebSocket, DOM::EventTarget);
JS_DECLARE_ALLOCATOR(WebSocket); JS_DECLARE_ALLOCATOR(WebSocket);
public: public:
enum class ReadyState : u16 {
Connecting = 0,
Open = 1,
Closing = 2,
Closed = 3,
};
static WebIDL::ExceptionOr<JS::NonnullGCPtr<WebSocket>> construct_impl(JS::Realm&, String const& url, Optional<Variant<String, Vector<String>>> const& protocols); static WebIDL::ExceptionOr<JS::NonnullGCPtr<WebSocket>> construct_impl(JS::Realm&, String const& url, Optional<Variant<String, Vector<String>>> const& protocols);
virtual ~WebSocket() override; virtual ~WebSocket() override;
@ -53,7 +45,7 @@ public:
ENUMERATE_WEBSOCKET_EVENT_HANDLERS(__ENUMERATE) ENUMERATE_WEBSOCKET_EVENT_HANDLERS(__ENUMERATE)
#undef __ENUMERATE #undef __ENUMERATE
ReadyState ready_state() const; Requests::WebSocket::ReadyState ready_state() const;
String extensions() const; String extensions() const;
WebIDL::ExceptionOr<String> protocol() const; WebIDL::ExceptionOr<String> protocol() const;
@ -77,44 +69,7 @@ private:
URL::URL m_url; URL::URL m_url;
String m_binary_type { "blob"_string }; String m_binary_type { "blob"_string };
RefPtr<WebSocketClientSocket> m_websocket; RefPtr<Requests::WebSocket> m_websocket;
};
class WebSocketClientSocket : public RefCounted<WebSocketClientSocket> {
public:
virtual ~WebSocketClientSocket();
struct CertificateAndKey {
ByteString certificate;
ByteString key;
};
struct Message {
ByteBuffer data;
bool is_text { false };
};
enum class Error {
CouldNotEstablishConnection,
ConnectionUpgradeFailed,
ServerClosedSocket,
};
virtual Web::WebSockets::WebSocket::ReadyState ready_state() = 0;
virtual ByteString subprotocol_in_use() = 0;
virtual void send(ByteBuffer binary_or_text_message, bool is_text) = 0;
virtual void send(StringView text_message) = 0;
virtual void close(u16 code = 1005, ByteString reason = {}) = 0;
Function<void()> on_open;
Function<void(Message)> on_message;
Function<void(Error)> on_error;
Function<void(u16 code, ByteString reason, bool was_clean)> on_close;
Function<CertificateAndKey()> on_certificate_requested;
protected:
explicit WebSocketClientSocket() = default;
}; };
} }

2
Userland/Libraries/LibWebView/CMakeLists.txt
View file

@ -10,14 +10,12 @@ set(SOURCES
ProcessHandle.cpp ProcessHandle.cpp
Process.cpp Process.cpp
ProcessManager.cpp ProcessManager.cpp
RequestServerAdapter.cpp
SearchEngine.cpp SearchEngine.cpp
SourceHighlighter.cpp SourceHighlighter.cpp
URL.cpp URL.cpp
UserAgent.cpp UserAgent.cpp
ViewImplementation.cpp ViewImplementation.cpp
WebContentClient.cpp WebContentClient.cpp
WebSocketClientAdapter.cpp
${PUBLIC_SUFFIX_SOURCES} ${PUBLIC_SUFFIX_SOURCES}
) )

98
Userland/Libraries/LibWebView/RequestServerAdapter.cpp
View file

@ -1,98 +0,0 @@
/*
* Copyright (c) 2022, Dex♪ <dexes.ttp@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include "WebSocketClientAdapter.h"
#include <LibRequests/Request.h>
#include <LibRequests/RequestClient.h>
#include <LibWebView/RequestServerAdapter.h>
namespace WebView {
ErrorOr<NonnullRefPtr<RequestServerRequestAdapter>> RequestServerRequestAdapter::try_create(NonnullRefPtr<Requests::Request> request)
{
return adopt_nonnull_ref_or_enomem(new (nothrow) RequestServerRequestAdapter(move(request)));
}
RequestServerRequestAdapter::RequestServerRequestAdapter(NonnullRefPtr<Requests::Request> request)
: m_request(request)
{
request->on_certificate_requested = [weak_this = make_weak_ptr()]() {
if (auto strong_this = weak_this.strong_ref()) {
if (strong_this->on_certificate_requested) {
auto certificate_and_key = strong_this->on_certificate_requested();
return Requests::Request::CertificateAndKey {
.certificate = move(certificate_and_key.certificate),
.key = move(certificate_and_key.key),
};
}
}
return Requests::Request::CertificateAndKey {};
};
}
RequestServerRequestAdapter::~RequestServerRequestAdapter() = default;
void RequestServerRequestAdapter::set_buffered_request_finished_callback(Requests::Request::BufferedRequestFinished on_buffered_request_finished)
{
m_request->set_buffered_request_finished_callback(move(on_buffered_request_finished));
}
void RequestServerRequestAdapter::set_unbuffered_request_callbacks(Requests::Request::HeadersReceived on_headers_received, Requests::Request::DataReceived on_data_received, Requests::Request::RequestFinished on_finished)
{
m_request->set_unbuffered_request_callbacks(move(on_headers_received), move(on_data_received), move(on_finished));
}
bool RequestServerRequestAdapter::stop()
{
return m_request->stop();
}
ErrorOr<NonnullRefPtr<RequestServerAdapter>> RequestServerAdapter::try_create(NonnullRefPtr<Requests::RequestClient> protocol_client)
{
return try_make_ref_counted<RequestServerAdapter>(move(protocol_client));
}
ErrorOr<NonnullRefPtr<RequestServerAdapter>> RequestServerAdapter::try_create()
{
auto protocol_client = TRY(Requests::RequestClient::try_create());
return try_make_ref_counted<RequestServerAdapter>(move(protocol_client));
}
RequestServerAdapter::RequestServerAdapter(NonnullRefPtr<Requests::RequestClient> protocol_client)
: m_protocol_client(protocol_client)
{
}
RequestServerAdapter::~RequestServerAdapter() = default;
RefPtr<Web::ResourceLoaderConnectorRequest> RequestServerAdapter::start_request(ByteString const& method, URL::URL const& url, HTTP::HeaderMap const& headers, ReadonlyBytes body, Core::ProxyData const& proxy)
{
auto protocol_request = m_protocol_client->start_request(method, url, headers, body, proxy);
if (!protocol_request)
return {};
return RequestServerRequestAdapter::try_create(protocol_request.release_nonnull()).release_value_but_fixme_should_propagate_errors();
}
RefPtr<Web::WebSockets::WebSocketClientSocket> RequestServerAdapter::websocket_connect(URL::URL const& url, AK::ByteString const& origin, Vector<AK::ByteString> const& protocols)
{
auto underlying_websocket = m_protocol_client->websocket_connect(url, origin, protocols);
if (!underlying_websocket)
return {};
return WebSocketClientSocketAdapter::create(underlying_websocket.release_nonnull());
}
void RequestServerAdapter::prefetch_dns(URL::URL const& url)
{
m_protocol_client->ensure_connection(url, RequestServer::CacheLevel::ResolveOnly);
}
void RequestServerAdapter::preconnect(URL::URL const& url)
{
m_protocol_client->ensure_connection(url, RequestServer::CacheLevel::CreateConnection);
}
}

55
Userland/Libraries/LibWebView/RequestServerAdapter.h
View file

@ -1,55 +0,0 @@
/*
* Copyright (c) 2022, Dex♪ <dexes.ttp@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Function.h>
#include <LibURL/URL.h>
#include <LibWeb/Loader/ResourceLoader.h>
#include <LibWeb/WebSockets/WebSocket.h>
namespace Requests {
class Request;
class RequestClient;
}
namespace WebView {
class RequestServerRequestAdapter
: public Web::ResourceLoaderConnectorRequest
, public Weakable<RequestServerRequestAdapter> {
public:
static ErrorOr<NonnullRefPtr<RequestServerRequestAdapter>> try_create(NonnullRefPtr<Requests::Request>);
virtual ~RequestServerRequestAdapter() override;
virtual void set_buffered_request_finished_callback(Requests::Request::BufferedRequestFinished) override;
virtual void set_unbuffered_request_callbacks(Requests::Request::HeadersReceived, Requests::Request::DataReceived, Requests::Request::RequestFinished) override;
virtual bool stop() override;
private:
RequestServerRequestAdapter(NonnullRefPtr<Requests::Request>);
NonnullRefPtr<Requests::Request> m_request;
};
class RequestServerAdapter : public Web::ResourceLoaderConnector {
public:
explicit RequestServerAdapter(NonnullRefPtr<Requests::RequestClient> protocol_client);
static ErrorOr<NonnullRefPtr<RequestServerAdapter>> try_create(NonnullRefPtr<Requests::RequestClient>);
static ErrorOr<NonnullRefPtr<RequestServerAdapter>> try_create();
virtual ~RequestServerAdapter() override;
virtual void prefetch_dns(URL::URL const& url) override;
virtual void preconnect(URL::URL const& url) override;
virtual RefPtr<Web::ResourceLoaderConnectorRequest> start_request(ByteString const& method, URL::URL const&, HTTP::HeaderMap const& request_headers = {}, ReadonlyBytes request_body = {}, Core::ProxyData const& = {}) override;
virtual RefPtr<Web::WebSockets::WebSocketClientSocket> websocket_connect(const URL::URL&, ByteString const& origin, Vector<ByteString> const& protocols) override;
private:
RefPtr<Requests::RequestClient> m_protocol_client;
};
}

110
Userland/Libraries/LibWebView/WebSocketClientAdapter.cpp
View file

@ -1,110 +0,0 @@
/*
* Copyright (c) 2022, Dex♪ <dexes.ttp@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibRequests/RequestClient.h>
#include <LibRequests/WebSocket.h>
#include <LibWebView/WebSocketClientAdapter.h>
namespace WebView {
RefPtr<WebSocketClientSocketAdapter> WebSocketClientSocketAdapter::create(NonnullRefPtr<Requests::WebSocket> websocket)
{
return adopt_ref(*new WebSocketClientSocketAdapter(move(websocket)));
}
WebSocketClientSocketAdapter::WebSocketClientSocketAdapter(NonnullRefPtr<Requests::WebSocket> websocket)
: m_websocket(move(websocket))
{
m_websocket->on_open = [weak_this = make_weak_ptr()] {
if (auto strong_this = weak_this.strong_ref())
if (strong_this->on_open)
strong_this->on_open();
};
m_websocket->on_message = [weak_this = make_weak_ptr()](auto message) {
if (auto strong_this = weak_this.strong_ref()) {
if (strong_this->on_message) {
strong_this->on_message(Web::WebSockets::WebSocketClientSocket::Message {
.data = move(message.data),
.is_text = message.is_text,
});
}
}
};
m_websocket->on_error = [weak_this = make_weak_ptr()](auto error) {
if (auto strong_this = weak_this.strong_ref()) {
if (strong_this->on_error) {
switch (error) {
case Requests::WebSocket::Error::CouldNotEstablishConnection:
strong_this->on_error(Web::WebSockets::WebSocketClientSocket::Error::CouldNotEstablishConnection);
return;
case Requests::WebSocket::Error::ConnectionUpgradeFailed:
strong_this->on_error(Web::WebSockets::WebSocketClientSocket::Error::ConnectionUpgradeFailed);
return;
case Requests::WebSocket::Error::ServerClosedSocket:
strong_this->on_error(Web::WebSockets::WebSocketClientSocket::Error::ServerClosedSocket);
return;
}
VERIFY_NOT_REACHED();
}
}
};
m_websocket->on_close = [weak_this = make_weak_ptr()](u16 code, ByteString reason, bool was_clean) {
if (auto strong_this = weak_this.strong_ref())
if (strong_this->on_close)
strong_this->on_close(code, move(reason), was_clean);
};
m_websocket->on_certificate_requested = [weak_this = make_weak_ptr()] {
if (auto strong_this = weak_this.strong_ref()) {
if (strong_this->on_certificate_requested) {
auto certificate_and_key = weak_this->on_certificate_requested();
return Requests::WebSocket::CertificateAndKey {
.certificate = move(certificate_and_key.certificate),
.key = move(certificate_and_key.key),
};
}
}
return Requests::WebSocket::CertificateAndKey {};
};
}
WebSocketClientSocketAdapter::~WebSocketClientSocketAdapter() = default;
Web::WebSockets::WebSocket::ReadyState WebSocketClientSocketAdapter::ready_state()
{
switch (m_websocket->ready_state()) {
case Requests::WebSocket::ReadyState::Connecting:
return Web::WebSockets::WebSocket::ReadyState::Connecting;
case Requests::WebSocket::ReadyState::Open:
return Web::WebSockets::WebSocket::ReadyState::Open;
case Requests::WebSocket::ReadyState::Closing:
return Web::WebSockets::WebSocket::ReadyState::Closing;
case Requests::WebSocket::ReadyState::Closed:
return Web::WebSockets::WebSocket::ReadyState::Closed;
}
VERIFY_NOT_REACHED();
}
ByteString WebSocketClientSocketAdapter::subprotocol_in_use()
{
return m_websocket->subprotocol_in_use();
}
void WebSocketClientSocketAdapter::send(ByteBuffer binary_or_text_message, bool is_text)
{
m_websocket->send(binary_or_text_message, is_text);
}
void WebSocketClientSocketAdapter::send(StringView text_message)
{
m_websocket->send(text_message);
}
void WebSocketClientSocketAdapter::close(u16 code, ByteString reason)
{
m_websocket->close(code, reason);
}
}

41
Userland/Libraries/LibWebView/WebSocketClientAdapter.h
View file

@ -1,41 +0,0 @@
/*
* Copyright (c) 2022, Dex♪ <dexes.ttp@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Error.h>
#include <AK/NonnullRefPtr.h>
#include <AK/Weakable.h>
#include <LibWeb/WebSockets/WebSocket.h>
namespace Requests {
class WebSocket;
class RequestClient;
};
namespace WebView {
class WebSocketClientSocketAdapter
: public Web::WebSockets::WebSocketClientSocket
, public Weakable<WebSocketClientSocketAdapter> {
public:
static RefPtr<WebSocketClientSocketAdapter> create(NonnullRefPtr<Requests::WebSocket>);
virtual ~WebSocketClientSocketAdapter() override;
virtual Web::WebSockets::WebSocket::ReadyState ready_state() override;
virtual ByteString subprotocol_in_use() override;
virtual void send(ByteBuffer binary_or_text_message, bool is_text) override;
virtual void send(StringView text_message) override;
virtual void close(u16 code = 1005, ByteString reason = {}) override;
private:
WebSocketClientSocketAdapter(NonnullRefPtr<Requests::WebSocket>);
NonnullRefPtr<Requests::WebSocket> m_websocket;
};
}