LibWeb: Abstract the LibProtocol ResourceLoader connection

This is the final component that required LibProtocol as a dependency
of LibWeb. With this, we can now remove the dependency, and LibWeb no
longer requires IPC to work :^)

Userland/Libraries/LibWebView/CMakeLists.txt

@@ -2,6 +2,7 @@ set(SOURCES
     DOMTreeModel.cpp
     ImageDecoderClientAdapter.cpp
     OutOfProcessWebView.cpp
+    RequestServerAdapter.cpp
     StylePropertiesModel.cpp
     WebContentClient.cpp
     WebSocketClientAdapter.cpp

Userland/Libraries/LibWebView/RequestServerAdapter.cpp

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2022, Dex♪ <dexes.ttp@gmail.com>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <LibCore/File.h>
+#include <LibProtocol/Request.h>
+#include <LibProtocol/RequestClient.h>
+#include <LibWebView/RequestServerAdapter.h>
+
+namespace WebView {
+
+ErrorOr<NonnullRefPtr<RequestServerRequestAdapter>> RequestServerRequestAdapter::try_create(NonnullRefPtr<Protocol::Request> request)
+{
+    return adopt_nonnull_ref_or_enomem(new (nothrow) RequestServerRequestAdapter(move(request)));
+}
+
+RequestServerRequestAdapter::RequestServerRequestAdapter(NonnullRefPtr<Protocol::Request> request)
+    : m_request(request)
+{
+    request->on_buffered_request_finish = [weak_this = make_weak_ptr()](auto success, auto total_size, auto const& response_headers, auto response_code, auto payload) {
+        if (auto strong_this = weak_this.strong_ref())
+            if (strong_this->on_buffered_request_finish)
+                strong_this->on_buffered_request_finish(success, total_size, response_headers, response_code, move(payload));
+    };
+
+    request->on_finish = [weak_this = make_weak_ptr()](bool success, u32 total_size) {
+        if (auto strong_this = weak_this.strong_ref())
+            if (strong_this->on_finish)
+                strong_this->on_finish(success, total_size);
+    };
+
+    request->on_progress = [weak_this = make_weak_ptr()](Optional<u32> total_size, u32 downloaded_size) {
+        if (auto strong_this = weak_this.strong_ref())
+            if (strong_this->on_progress)
+                strong_this->on_progress(total_size, downloaded_size);
+    };
+
+    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 Protocol::Request::CertificateAndKey {
+                    .certificate = move(certificate_and_key.certificate),
+                    .key = move(certificate_and_key.key),
+                };
+            }
+        }
+
+        return Protocol::Request::CertificateAndKey {};
+    };
+}
+
+RequestServerRequestAdapter::~RequestServerRequestAdapter() = default;
+
+void RequestServerRequestAdapter::set_should_buffer_all_input(bool should_buffer_all_input)
+{
+    m_request->set_should_buffer_all_input(should_buffer_all_input);
+}
+
+bool RequestServerRequestAdapter::stop()
+{
+    return m_request->stop();
+}
+
+void RequestServerRequestAdapter::stream_into(Core::Stream::Stream& stream)
+{
+    m_request->stream_into(stream);
+}
+
+ErrorOr<NonnullRefPtr<RequestServerAdapter>> RequestServerAdapter::try_create()
+{
+    auto protocol_client = TRY(Protocol::RequestClient::try_create());
+    return adopt_nonnull_ref_or_enomem(new (nothrow) RequestServerAdapter(move(protocol_client)));
+}
+
+RequestServerAdapter::RequestServerAdapter(NonnullRefPtr<Protocol::RequestClient> protocol_client)
+    : m_protocol_client(protocol_client)
+{
+}
+
+RequestServerAdapter::~RequestServerAdapter() = default;
+
+RefPtr<Web::ResourceLoaderConnectorRequest> RequestServerAdapter::start_request(String const& method, URL const& url, HashMap<String, String> 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();
+}
+
+void RequestServerAdapter::prefetch_dns(AK::URL const& url)
+{
+    m_protocol_client->ensure_connection(url, RequestServer::CacheLevel::ResolveOnly);
+}
+
+void RequestServerAdapter::preconnect(AK::URL const& url)
+{
+    m_protocol_client->ensure_connection(url, RequestServer::CacheLevel::CreateConnection);
+}
+
+}

Userland/Libraries/LibWebView/RequestServerAdapter.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2022, Dex♪ <dexes.ttp@gmail.com>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Function.h>
+#include <AK/URL.h>
+#include <LibWeb/Loader/ResourceLoader.h>
+
+namespace Protocol {
+class Request;
+class RequestClient;
+}
+
+namespace WebView {
+
+class RequestServerRequestAdapter
+    : public Web::ResourceLoaderConnectorRequest
+    , public Weakable<RequestServerRequestAdapter> {
+public:
+    static ErrorOr<NonnullRefPtr<RequestServerRequestAdapter>> try_create(NonnullRefPtr<Protocol::Request>);
+    virtual ~RequestServerRequestAdapter() override;
+
+    virtual void set_should_buffer_all_input(bool) override;
+    virtual bool stop() override;
+
+    virtual void stream_into(Core::Stream::Stream&) override;
+
+private:
+    RequestServerRequestAdapter(NonnullRefPtr<Protocol::Request>);
+    NonnullRefPtr<Protocol::Request> m_request;
+};
+
+class RequestServerAdapter : public Web::ResourceLoaderConnector {
+public:
+    static ErrorOr<NonnullRefPtr<RequestServerAdapter>> try_create();
+    virtual ~RequestServerAdapter() override;
+
+    virtual void prefetch_dns(AK::URL const& url) override;
+    virtual void preconnect(AK::URL const& url) override;
+
+    virtual RefPtr<Web::ResourceLoaderConnectorRequest> start_request(String const& method, URL const&, HashMap<String, String> const& request_headers = {}, ReadonlyBytes request_body = {}, Core::ProxyData const& = {}) override;
+
+private:
+    RequestServerAdapter(NonnullRefPtr<Protocol::RequestClient> protocol_client);
+
+    RefPtr<Protocol::RequestClient> m_protocol_client;
+};
+
+}