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 :^)

1 files changed, 103 insertions, 0 deletions

diff --git a/Userland/Libraries/LibWebView/RequestServerAdapter.cpp b/Userland/Libraries/LibWebView/RequestServerAdapter.cpp
new file mode 100644
index 0000000000..be2374d869
--- /dev/null
+++ b/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);
+}
+
+}