LibWeb+WebContent: Move display list rasterization off the main thread

The display list is an immutable data structure, so once it's created,
rasterization can be moved to a separate thread. This allows more room
for performing other tasks between processing HTML rendering tasks.

This change makes PaintingSurface, ImmutableBitmap, and GlyphRun atomic
ref-counted, as they are shared between the main and rendering threads
by being included in the display list.

Libraries/LibWeb/HTML/RenderingThread.cpp

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2025, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <LibCore/EventLoop.h>
+#include <LibWeb/HTML/RenderingThread.h>
+
+namespace Web::HTML {
+
+RenderingThread::RenderingThread()
+    : m_main_thread_event_loop(Core::EventLoop::current())
+{
+}
+
+RenderingThread::~RenderingThread()
+{
+    m_exit = true;
+    m_rendering_task_ready_wake_condition.signal();
+    (void)m_thread->join();
+}
+
+void RenderingThread::start()
+{
+    VERIFY(m_skia_player);
+    m_thread = Threading::Thread::construct([this] {
+        rendering_thread_loop();
+        return static_cast<intptr_t>(0);
+    });
+    m_thread->start();
+}
+
+void RenderingThread::rendering_thread_loop()
+{
+    while (true) {
+        auto task = [this]() -> Optional<Task> {
+            Threading::MutexLocker const locker { m_rendering_task_mutex };
+            while (m_rendering_tasks.is_empty() && !m_exit) {
+                m_rendering_task_ready_wake_condition.wait();
+            }
+            if (m_exit)
+                return {};
+            return m_rendering_tasks.dequeue();
+        }();
+
+        if (!task.has_value()) {
+            VERIFY(m_exit);
+            break;
+        }
+
+        m_skia_player->set_surface(task->painting_surface);
+        m_skia_player->execute(*task->display_list);
+        m_main_thread_event_loop.deferred_invoke([callback = move(task->callback)] {
+            callback();
+        });
+    }
+}
+
+void RenderingThread::enqueue_rendering_task(RefPtr<Painting::DisplayList> display_list, NonnullRefPtr<Gfx::PaintingSurface> painting_surface, Function<void()>&& callback)
+{
+    Threading::MutexLocker const locker { m_rendering_task_mutex };
+    m_rendering_tasks.enqueue(Task { move(display_list), move(painting_surface), move(callback) });
+    m_rendering_task_ready_wake_condition.signal();
+}
+
+}

Libraries/LibWeb/HTML/RenderingThread.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2025, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Noncopyable.h>
+#include <AK/Queue.h>
+#include <LibThreading/ConditionVariable.h>
+#include <LibThreading/Mutex.h>
+#include <LibThreading/Thread.h>
+#include <LibWeb/Painting/DisplayListPlayerSkia.h>
+
+namespace Web::HTML {
+
+class RenderingThread {
+    AK_MAKE_NONCOPYABLE(RenderingThread);
+    AK_MAKE_NONMOVABLE(RenderingThread);
+
+public:
+    RenderingThread();
+    ~RenderingThread();
+
+    void start();
+    void set_skia_player(OwnPtr<Painting::DisplayListPlayerSkia>&& player) { m_skia_player = move(player); }
+    void enqueue_rendering_task(RefPtr<Painting::DisplayList>, NonnullRefPtr<Gfx::PaintingSurface>, Function<void()>&& callback);
+
+private:
+    void rendering_thread_loop();
+
+    Core::EventLoop& m_main_thread_event_loop;
+
+    OwnPtr<Painting::DisplayListPlayerSkia> m_skia_player;
+
+    RefPtr<Threading::Thread> m_thread;
+    Atomic<bool> m_exit { false };
+
+    struct Task {
+        RefPtr<Painting::DisplayList> display_list;
+        NonnullRefPtr<Gfx::PaintingSurface> painting_surface;
+        Function<void()> callback;
+    };
+    // NOTE: Queue will only contain multiple items in case tasks were scheduled by screenshot requests.
+    //       Otherwise, it will contain only one item at a time.
+    Queue<Task> m_rendering_tasks;
+    Threading::Mutex m_rendering_task_mutex;
+    Threading::ConditionVariable m_rendering_task_ready_wake_condition { m_rendering_task_mutex };
+};
+
+}

Libraries/LibWeb/HTML/TraversableNavigable.cpp

@@ -53,12 +53,16 @@ TraversableNavigable::TraversableNavigable(GC::Ref<Page> page)
     , m_session_history_traversal_queue(vm().heap().allocate<SessionHistoryTraversalQueue>())
 {
     auto display_list_player_type = page->client().display_list_player_type();
+    OwnPtr<Painting::DisplayListPlayerSkia> skia_player;
     if (display_list_player_type == DisplayListPlayerType::SkiaGPUIfAvailable) {
         m_skia_backend_context = get_skia_backend_context();
-        m_skia_player = make<Painting::DisplayListPlayerSkia>(m_skia_backend_context);
+        skia_player = make<Painting::DisplayListPlayerSkia>(m_skia_backend_context);
     } else {
-        m_skia_player = make<Painting::DisplayListPlayerSkia>();
+        skia_player = make<Painting::DisplayListPlayerSkia>();
     }
+
+    m_rendering_thread.set_skia_player(move(skia_player));
+    m_rendering_thread.start();
 }
 
 TraversableNavigable::~TraversableNavigable() = default;
@@ -1429,13 +1433,13 @@ NonnullRefPtr<Gfx::PaintingSurface> TraversableNavigable::painting_surface_for_b
     return *new_surface;
 }
 
-void TraversableNavigable::paint(DevicePixelRect const& content_rect, Painting::BackingStore& target, PaintOptions paint_options)
+RefPtr<Painting::DisplayList> TraversableNavigable::record_display_list(DevicePixelRect const& content_rect, PaintOptions paint_options)
 {
     m_needs_repaint = false;
 
     auto document = active_document();
     if (!document)
-        return;
+        return {};
 
     for (auto& navigable : all_navigables()) {
         if (auto active_document = navigable->active_document(); active_document && active_document->paintable())
@@ -1447,13 +1451,12 @@ void TraversableNavigable::paint(DevicePixelRect const& content_rect, Painting::
     paint_config.should_show_line_box_borders = paint_options.should_show_line_box_borders;
     paint_config.has_focus = paint_options.has_focus;
     paint_config.canvas_fill_rect = Gfx::IntRect { {}, content_rect.size() };
-    auto display_list = document->record_display_list(paint_config);
-    if (!display_list)
-        return;
+    return document->record_display_list(paint_config);
+}
 
-    auto painting_surface = painting_surface_for_backing_store(target);
-    m_skia_player->set_surface(painting_surface);
-    m_skia_player->execute(*display_list);
+void TraversableNavigable::start_display_list_rendering(RefPtr<Painting::DisplayList> display_list, NonnullRefPtr<Gfx::PaintingSurface> painting_surface, Function<void()>&& callback)
+{
+    m_rendering_thread.enqueue_rendering_task(move(display_list), move(painting_surface), move(callback));
 }
 
 }

Libraries/LibWeb/HTML/TraversableNavigable.h

@@ -9,12 +9,12 @@
 #include <AK/Vector.h>
 #include <LibWeb/HTML/Navigable.h>
 #include <LibWeb/HTML/NavigationType.h>
+#include <LibWeb/HTML/RenderingThread.h>
 #include <LibWeb/HTML/SessionHistoryTraversalQueue.h>
 #include <LibWeb/HTML/VisibilityState.h>
 #include <LibWeb/Page/Page.h>
 #include <LibWeb/Painting/DisplayListPlayerSkia.h>
 #include <LibWeb/StorageAPI/StorageShed.h>
-#include <WebContent/BackingStoreManager.h>
 
 #ifdef AK_OS_MACOS
 #    include <LibGfx/MetalContext.h>
@@ -97,7 +97,8 @@ public:
 
     [[nodiscard]] GC::Ptr<DOM::Node> currently_focused_area();
 
-    void paint(Web::DevicePixelRect const&, Painting::BackingStore&, Web::PaintOptions);
+    RefPtr<Painting::DisplayList> record_display_list(DevicePixelRect const&, PaintOptions);
+    void start_display_list_rendering(RefPtr<Painting::DisplayList> display_list, NonnullRefPtr<Gfx::PaintingSurface> painting_surface, Function<void()>&& callback);
 
     enum class CheckIfUnloadingIsCanceledResult {
         CanceledByBeforeUnload,
@@ -116,6 +117,8 @@ public:
     bool needs_repaint() const { return m_needs_repaint; }
     void set_needs_repaint() { m_needs_repaint = true; }
 
+    NonnullRefPtr<Gfx::PaintingSurface> painting_surface_for_backing_store(Painting::BackingStore&);
+
 private:
     TraversableNavigable(GC::Ref<Page>);
 
@@ -137,8 +140,6 @@ private:
 
     [[nodiscard]] bool can_go_forward() const;
 
-    NonnullRefPtr<Gfx::PaintingSurface> painting_surface_for_backing_store(Painting::BackingStore&);
-
     // https://html.spec.whatwg.org/multipage/document-sequences.html#tn-current-session-history-step
     int m_current_session_history_step { 0 };
 
@@ -162,10 +163,11 @@ private:
     String m_window_handle;
 
     RefPtr<Gfx::SkiaBackendContext> m_skia_backend_context;
-    OwnPtr<Painting::DisplayListPlayerSkia> m_skia_player;
     HashMap<Gfx::Bitmap*, NonnullRefPtr<Gfx::PaintingSurface>> m_bitmap_to_surface;
 
     bool m_needs_repaint { true };
+
+    RenderingThread m_rendering_thread;
 };
 
 struct BrowsingContextAndDocument {