LibWeb+LibWebView+WebWorker: Send service sockets to workers over IPC

Instead of passing RequestServer and ImageDecoder socket FDs as
command-line arguments to WebWorker, send them over the main IPC channel
after launch. The worker-agent handoff now carries all three transport
handles (worker, RequestServer, ImageDecoder) so the connection path
matches WebContent.

Services/WebContent/PageClient.cpp

@@ -731,7 +731,7 @@ void PageClient::page_did_allocate_backing_stores(i32 front_bitmap_id, Gfx::Shar
     client().async_did_allocate_backing_stores(m_id, front_bitmap_id, front_bitmap, back_bitmap_id, back_bitmap);
 }
 
-IPC::TransportHandle PageClient::request_worker_agent(Web::Bindings::AgentType type)
+Web::PageClient::WorkerAgentResponse PageClient::request_worker_agent(Web::Bindings::AgentType type)
 {
     auto response = client().send_sync_but_allow_failure<Messages::WebContentClient::RequestWorkerAgent>(m_id, type);
     if (!response) {
@@ -739,7 +739,7 @@ IPC::TransportHandle PageClient::request_worker_agent(Web::Bindings::AgentType t
         exit(0);
     }
 
-    return response->take_handle();
+    return { response->take_handle(), response->take_request_server_handle(), response->take_image_decoder_handle() };
 }
 
 void PageClient::page_did_mutate_dom(FlyString const& type, Web::DOM::Node const& target, Web::DOM::NodeList& added_nodes, Web::DOM::NodeList& removed_nodes, GC::Ptr<Web::DOM::Node>, GC::Ptr<Web::DOM::Node>, Optional<String> const& attribute_name)

Services/WebContent/PageClient.h

@@ -188,7 +188,7 @@ private:
     virtual void page_did_request_clipboard_entries(u64 request_id) override;
     virtual void page_did_change_audio_play_state(Web::HTML::AudioPlayState) override;
     virtual void page_did_allocate_backing_stores(i32 front_bitmap_id, Gfx::ShareableBitmap front_bitmap, i32 back_bitmap_id, Gfx::ShareableBitmap back_bitmap) override;
-    virtual IPC::TransportHandle request_worker_agent(Web::Bindings::AgentType) override;
+    virtual WorkerAgentResponse request_worker_agent(Web::Bindings::AgentType) override;
     virtual void page_did_mutate_dom(FlyString const& type, Web::DOM::Node const& target, Web::DOM::NodeList& added_nodes, Web::DOM::NodeList& removed_nodes, GC::Ptr<Web::DOM::Node> previous_sibling, GC::Ptr<Web::DOM::Node> next_sibling, Optional<String> const& attribute_name) override;
     virtual void page_did_paint(Gfx::IntRect const& content_rect, i32 bitmap_id) override;
     virtual void page_did_take_screenshot(Gfx::ShareableBitmap const& screenshot) override;

Services/WebContent/WebContentClient.ipc

@@ -135,5 +135,5 @@ endpoint WebContentClient
 
     did_find_in_page(u64 page_id, size_t current_match_index, Optional<size_t> total_match_count) =|
 
-    request_worker_agent(u64 page_id, Web::Bindings::AgentType worker_type) => (IPC::TransportHandle handle) // FIXME: Add required attributes to select a SharedWorker Agent
+    request_worker_agent(u64 page_id, Web::Bindings::AgentType worker_type) => (IPC::TransportHandle handle, IPC::TransportHandle request_server_handle, IPC::TransportHandle image_decoder_handle) // FIXME: Add required attributes to select a SharedWorker Agent
 }

Services/WebWorker/ConnectionFromClient.cpp

@@ -11,6 +11,18 @@
 
 namespace WebWorker {
 
+void ConnectionFromClient::connect_to_request_server(IPC::TransportHandle handle)
+{
+    if (on_request_server_connection)
+        on_request_server_connection(handle);
+}
+
+void ConnectionFromClient::connect_to_image_decoder(IPC::TransportHandle handle)
+{
+    if (on_image_decoder_connection)
+        on_image_decoder_connection(handle);
+}
+
 void ConnectionFromClient::close_worker()
 {
     async_did_close_worker();

Services/WebWorker/ConnectionFromClient.h

@@ -35,12 +35,17 @@ public:
     PageHost& page_host() { return *m_page_host; }
     PageHost const& page_host() const { return *m_page_host; }
 
+    Function<void(IPC::TransportHandle const&)> on_request_server_connection;
+    Function<void(IPC::TransportHandle const&)> on_image_decoder_connection;
+
 private:
     explicit ConnectionFromClient(NonnullOwnPtr<IPC::Transport>);
 
     Web::Page& page();
     Web::Page const& page() const;
 
+    virtual void connect_to_request_server(IPC::TransportHandle handle) override;
+    virtual void connect_to_image_decoder(IPC::TransportHandle handle) override;
     virtual void start_worker(URL::URL url, Web::Bindings::WorkerType type, Web::Bindings::RequestCredentials credentials, String name, Web::HTML::TransferDataEncoder, Web::HTML::SerializedEnvironmentSettingsObject, Web::Bindings::AgentType) override;
     virtual void handle_file_return(i32 error, Optional<IPC::File> file, i32 request_id) override;
 

Services/WebWorker/PageHost.cpp

@@ -97,9 +97,10 @@ void PageHost::request_file(Web::FileRequest request)
     m_client.request_file(move(request));
 }
 
-IPC::TransportHandle PageHost::request_worker_agent(Web::Bindings::AgentType worker_type)
+Web::PageClient::WorkerAgentResponse PageHost::request_worker_agent(Web::Bindings::AgentType worker_type)
 {
-    return m_client.request_worker_agent(worker_type);
+    auto response = m_client.request_worker_agent(worker_type);
+    return { response.take_handle(), response.take_request_server_handle(), response.take_image_decoder_handle() };
 }
 
 void PageHost::did_fail_loading_worker_script()

Services/WebWorker/PageHost.h

@@ -38,7 +38,7 @@ public:
     virtual size_t screen_count() const override { return 1; }
     virtual HTTP::Cookie::VersionedCookie page_did_request_cookie(URL::URL const&, HTTP::Cookie::Source) override;
     virtual void request_file(Web::FileRequest) override;
-    virtual IPC::TransportHandle request_worker_agent(Web::Bindings::AgentType) override;
+    virtual WorkerAgentResponse request_worker_agent(Web::Bindings::AgentType) override;
     virtual Web::DisplayListPlayerType display_list_player_type() const override { VERIFY_NOT_REACHED(); }
     virtual bool is_headless() const override { VERIFY_NOT_REACHED(); }
     virtual Queue<Web::QueuedInputEvent>& input_event_queue() override { VERIFY_NOT_REACHED(); }

Services/WebWorker/main.cpp

@@ -11,7 +11,10 @@
 #include <LibCrypto/OpenSSLForward.h>
 #include <LibFileSystem/FileSystem.h>
 #include <LibIPC/SingleServer.h>
+#include <LibIPC/TransportHandle.h>
+#include <LibImageDecoderClient/Client.h>
 #include <LibMain/Main.h>
+#include <LibRequests/RequestClient.h>
 #include <LibWeb/Bindings/MainThreadVM.h>
 #include <LibWeb/Fetch/Fetching/Fetching.h>
 #include <LibWeb/HTML/UniversalGlobalScope.h>
@@ -19,15 +22,14 @@
 #include <LibWeb/Loader/ResourceLoader.h>
 #include <LibWeb/Platform/EventLoopPlugin.h>
 #include <LibWeb/Platform/FontPlugin.h>
-#include <LibWebView/HelperProcess.h>
 #include <LibWebView/Plugins/ImageCodecPlugin.h>
 #include <LibWebView/Utilities.h>
 #include <WebWorker/ConnectionFromClient.h>
 
 #include <openssl/thread.h>
 
-static ErrorOr<void> initialize_image_decoder(int image_decoder_socket);
-static ErrorOr<void> initialize_resource_loader(GC::Heap&, int request_server_socket);
+static ErrorOr<void> connect_to_resource_loader(GC::Heap& heap, IPC::TransportHandle const& handle);
+static ErrorOr<void> connect_to_image_decoder(IPC::TransportHandle const& handle);
 
 static ErrorOr<Web::Bindings::AgentType> agent_type_from_string(StringView type)
 {
@@ -45,8 +47,6 @@ ErrorOr<int> ladybird_main(Main::Arguments arguments)
 {
     AK::set_rich_debug_enabled(true);
 
-    int request_server_socket { -1 };
-    int image_decoder_socket { -1 };
     StringView serenity_resource_root;
     StringView worker_type_string;
     Vector<ByteString> certificates;
@@ -56,8 +56,6 @@ ErrorOr<int> ladybird_main(Main::Arguments arguments)
     bool file_origins_are_tuple_origins = false;
 
     Core::ArgsParser args_parser;
-    args_parser.add_option(request_server_socket, "File descriptor of the request server socket", "request-server-socket", 's', "request-server-socket");
-    args_parser.add_option(image_decoder_socket, "File descriptor of the socket for the ImageDecoder connection", "image-decoder-socket", 'i', "image_decoder_socket");
     args_parser.add_option(serenity_resource_root, "Absolute path to directory for serenity resources", "serenity-resource-root", 'r', "serenity-resource-root");
     args_parser.add_option(certificates, "Path to a certificate file", "certificate", 'C', "certificate");
     args_parser.add_option(expose_experimental_interfaces, "Expose experimental IDL interfaces", "expose-experimental-interfaces");
@@ -85,8 +83,6 @@ ErrorOr<int> ladybird_main(Main::Arguments arguments)
 
     OPENSSL_TRY(OSSL_set_max_threads(nullptr, Core::System::hardware_concurrency()));
 
-    TRY(initialize_image_decoder(image_decoder_socket));
-
     Web::HTML::UniversalGlobalScopeMixin::set_experimental_interfaces_exposed(expose_experimental_interfaces);
 
     Web::Platform::EventLoopPlugin::install(*new Web::Platform::EventLoopPlugin);
@@ -95,50 +91,47 @@ ErrorOr<int> ladybird_main(Main::Arguments arguments)
 
     Web::Bindings::initialize_main_thread_vm(worker_type);
 
-    TRY(initialize_resource_loader(Web::Bindings::main_thread_vm().heap(), request_server_socket));
-
     auto client = TRY(IPC::take_over_accepted_client_from_system_server<WebWorker::ConnectionFromClient>());
 
+    auto& heap = Web::Bindings::main_thread_vm().heap();
+    client->on_request_server_connection = [&heap](auto const& handle) {
+        if (auto result = connect_to_resource_loader(heap, handle); result.is_error())
+            dbgln("Failed to connect to resource loader: {}", result.error());
+    };
+    client->on_image_decoder_connection = [](auto const& handle) {
+        if (auto result = connect_to_image_decoder(handle); result.is_error())
+            dbgln("Failed to connect to image decoder: {}", result.error());
+    };
+
     return event_loop.exec();
 }
 
-static ErrorOr<void> initialize_image_decoder(int image_decoder_socket)
+static ErrorOr<void> connect_to_resource_loader(GC::Heap& heap, IPC::TransportHandle const& handle)
 {
-#if !defined(AK_OS_WINDOWS)
-    static_assert(IsSame<IPC::Transport, IPC::TransportSocket>, "Need to handle other IPC transports here");
-#else
-    static_assert(IsSame<IPC::Transport, IPC::TransportSocketWindows>, "Need to handle other IPC transports here");
-#endif
-    auto socket = TRY(Core::LocalSocket::adopt_fd(image_decoder_socket));
-    TRY(socket->set_blocking(true));
-
-    auto new_client = TRY(try_make_ref_counted<ImageDecoderClient::Client>(make<IPC::Transport>(move(socket))));
-#ifdef AK_OS_WINDOWS
-    auto response = new_client->send_sync<Messages::ImageDecoderServer::InitTransport>(Core::System::getpid());
-    new_client->transport().set_peer_pid(response->peer_pid());
-#endif
-
-    Web::Platform::ImageCodecPlugin::install(*new WebView::ImageCodecPlugin(move(new_client)));
-
-    return {};
-}
-
-static ErrorOr<void> initialize_resource_loader(GC::Heap& heap, int request_server_socket)
-{
-#if !defined(AK_OS_WINDOWS)
-    static_assert(IsSame<IPC::Transport, IPC::TransportSocket>, "Need to handle other IPC transports here");
-#else
-    static_assert(IsSame<IPC::Transport, IPC::TransportSocketWindows>, "Need to handle other IPC transports here");
-#endif
-    auto socket = TRY(Core::LocalSocket::adopt_fd(request_server_socket));
-    TRY(socket->set_blocking(true));
-
-    auto request_client = TRY(try_make_ref_counted<Requests::RequestClient>(make<IPC::Transport>(move(socket))));
+    auto transport = TRY(handle.create_transport());
+    auto request_client = TRY(try_make_ref_counted<Requests::RequestClient>(move(transport)));
 #ifdef AK_OS_WINDOWS
     auto response = request_client->send_sync<Messages::RequestServer::InitTransport>(Core::System::getpid());
     request_client->transport().set_peer_pid(response->peer_pid());
 #endif
-    Web::ResourceLoader::initialize(heap, move(request_client));
-
+    if (Web::ResourceLoader::is_initialized())
+        Web::ResourceLoader::the().set_client(move(request_client));
+    else
+        Web::ResourceLoader::initialize(heap, move(request_client));
+    return {};
+}
+
+static ErrorOr<void> connect_to_image_decoder(IPC::TransportHandle const& handle)
+{
+    auto transport = TRY(handle.create_transport());
+    auto new_client = TRY(try_make_ref_counted<ImageDecoderClient::Client>(move(transport)));
+#ifdef AK_OS_WINDOWS
+    auto response = new_client->send_sync<Messages::ImageDecoderServer::InitTransport>(Core::System::getpid());
+    new_client->transport().set_peer_pid(response->peer_pid());
+#endif
+    if (Web::Platform::ImageCodecPlugin::is_initialized())
+        static_cast<WebView::ImageCodecPlugin&>(Web::Platform::ImageCodecPlugin::the()).set_client(move(new_client));
+    else
+        Web::Platform::ImageCodecPlugin::install(*new WebView::ImageCodecPlugin(move(new_client)));
     return {};
 }