LibWeb: Schedule input event processing on HTML event loop

Our existing coalescing mechanism for input events didn't prevent
multiple mousemove/mousewheel events from being processed between paint
cycles. Since handling these events can trigger style & layout updates
solely for hit-testing purposes, we might end up doing work that won't
be observable by a user and could be avoided by shceduling input events
processing to happen right before painting the next frame.

Libraries/LibWeb/HTML/EventLoop/EventLoop.cpp

@@ -252,6 +252,63 @@ void EventLoop::queue_task_to_update_the_rendering()
     }
 }
 
+void EventLoop::process_input_events() const
+{
+    auto process_input_events_queue = [&](Page& page) {
+        auto& page_client = page.client();
+        auto& input_events_queue = page_client.input_event_queue();
+        while (!input_events_queue.is_empty()) {
+            auto event = input_events_queue.dequeue();
+            auto result = event.event.visit(
+                [&](KeyEvent const& key_event) {
+                    switch (key_event.type) {
+                    case KeyEvent::Type::KeyDown:
+                        return page.handle_keydown(key_event.key, key_event.modifiers, key_event.code_point, key_event.repeat);
+                    case KeyEvent::Type::KeyUp:
+                        return page.handle_keyup(key_event.key, key_event.modifiers, key_event.code_point, key_event.repeat);
+                    }
+                    VERIFY_NOT_REACHED();
+                },
+                [&](MouseEvent const& mouse_event) {
+                    switch (mouse_event.type) {
+                    case MouseEvent::Type::MouseDown:
+                        return page.handle_mousedown(mouse_event.position, mouse_event.screen_position, mouse_event.button, mouse_event.buttons, mouse_event.modifiers);
+                    case MouseEvent::Type::MouseUp:
+                        return page.handle_mouseup(mouse_event.position, mouse_event.screen_position, mouse_event.button, mouse_event.buttons, mouse_event.modifiers);
+                    case MouseEvent::Type::MouseMove:
+                        return page.handle_mousemove(mouse_event.position, mouse_event.screen_position, mouse_event.buttons, mouse_event.modifiers);
+                    case MouseEvent::Type::MouseWheel:
+                        return page.handle_mousewheel(mouse_event.position, mouse_event.screen_position, mouse_event.button, mouse_event.buttons, mouse_event.modifiers, mouse_event.wheel_delta_x, mouse_event.wheel_delta_y);
+                    case MouseEvent::Type::DoubleClick:
+                        return page.handle_doubleclick(mouse_event.position, mouse_event.screen_position, mouse_event.button, mouse_event.buttons, mouse_event.modifiers);
+                    }
+                    VERIFY_NOT_REACHED();
+                },
+                [&](Web::DragEvent& drag_event) {
+                    return page.handle_drag_and_drop_event(drag_event.type, drag_event.position, drag_event.screen_position, drag_event.button, drag_event.buttons, drag_event.modifiers, move(drag_event.files));
+                });
+
+            for (size_t i = 0; i < event.coalesced_event_count; ++i)
+                page_client.report_finished_handling_input_event(event.page_id, EventResult::Dropped);
+            page_client.report_finished_handling_input_event(event.page_id, result);
+        }
+    };
+
+    auto documents_of_traversable_navigables = documents_in_this_event_loop_matching([&](auto const& document) {
+        if (document.is_decoded_svg())
+            return false;
+        if (!document.navigable())
+            return false;
+        if (!document.navigable()->is_traversable())
+            return false;
+        return true;
+    });
+
+    for (auto const& document : documents_of_traversable_navigables) {
+        process_input_events_queue(document->page());
+    }
+}
+
 // https://html.spec.whatwg.org/multipage/webappapis.html#update-the-rendering
 void EventLoop::update_the_rendering()
 {
@@ -261,6 +318,8 @@ void EventLoop::update_the_rendering()
         m_is_running_rendering_task = false;
     };
 
+    process_input_events();
+
     // 1. Let frameTimestamp be eventLoop's last render opportunity time.
     auto frame_timestamp = m_last_render_opportunity_time;
 

Libraries/LibWeb/HTML/EventLoop/EventLoop.h

@@ -95,6 +95,7 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
+    void process_input_events() const;
     void update_the_rendering();
 
     Type m_type { Type::Window };

Libraries/LibWeb/Page/InputEvent.h

@@ -85,6 +85,12 @@ struct DragEvent {
 
 using InputEvent = Variant<KeyEvent, MouseEvent, DragEvent>;
 
+struct QueuedInputEvent {
+    u64 page_id { 0 };
+    InputEvent event;
+    size_t coalesced_event_count { 0 };
+};
+
 }
 
 namespace IPC {

Libraries/LibWeb/Page/Page.h

@@ -323,6 +323,8 @@ public:
     virtual void paint_next_frame() = 0;
     virtual void process_screenshot_requests() = 0;
     virtual void paint(DevicePixelRect const&, Painting::BackingStore&, PaintOptions = {}) = 0;
+    virtual Queue<QueuedInputEvent>& input_event_queue() = 0;
+    virtual void report_finished_handling_input_event(u64 page_id, EventResult event_was_handled) = 0;
     virtual void page_did_change_title(ByteString const&) { }
     virtual void page_did_change_url(URL::URL const&) { }
     virtual void page_did_request_refresh() { }

Libraries/LibWeb/SVG/SVGDecodedImageData.h

@@ -80,6 +80,8 @@ public:
     virtual void process_screenshot_requests() override { }
     virtual void paint(DevicePixelRect const&, Painting::BackingStore&, Web::PaintOptions = {}) override { }
     virtual bool is_ready_to_paint() const override { return true; }
+    virtual Queue<QueuedInputEvent>& input_event_queue() override { VERIFY_NOT_REACHED(); }
+    virtual void report_finished_handling_input_event([[maybe_unused]] u64 page_id, [[maybe_unused]] EventResult event_was_handled) override { }
 
     virtual DisplayListPlayerType display_list_player_type() const override { return m_host_page->client().display_list_player_type(); }
     virtual bool is_headless() const override { return m_host_page->client().is_headless(); }

Services/WebContent/ConnectionFromClient.cpp

@@ -60,7 +60,6 @@ ConnectionFromClient::ConnectionFromClient(GC::Heap& heap, IPC::Transport transp
     , m_heap(heap)
     , m_page_host(PageHost::create(*this))
 {
-    m_input_event_queue_timer = Web::Platform::Timer::create_single_shot(m_heap, 0, GC::create_function(heap, [this] { process_next_input_event(); }));
 }
 
 ConnectionFromClient::~ConnectionFromClient() = default;
@@ -186,55 +185,6 @@ void ConnectionFromClient::ready_to_paint(u64 page_id)
         page->ready_to_paint();
 }
 
-void ConnectionFromClient::process_next_input_event()
-{
-    if (m_input_event_queue.is_empty())
-        return;
-
-    auto event = m_input_event_queue.dequeue();
-
-    auto page = this->page(event.page_id);
-    if (!page.has_value())
-        return;
-
-    auto result = event.event.visit(
-        [&](Web::KeyEvent const& event) {
-            switch (event.type) {
-            case Web::KeyEvent::Type::KeyDown:
-                return page->page().handle_keydown(event.key, event.modifiers, event.code_point, event.repeat);
-            case Web::KeyEvent::Type::KeyUp:
-                return page->page().handle_keyup(event.key, event.modifiers, event.code_point, event.repeat);
-            }
-            VERIFY_NOT_REACHED();
-        },
-        [&](Web::MouseEvent const& event) {
-            switch (event.type) {
-            case Web::MouseEvent::Type::MouseDown:
-                return page->page().handle_mousedown(event.position, event.screen_position, event.button, event.buttons, event.modifiers);
-            case Web::MouseEvent::Type::MouseUp:
-                return page->page().handle_mouseup(event.position, event.screen_position, event.button, event.buttons, event.modifiers);
-            case Web::MouseEvent::Type::MouseMove:
-                return page->page().handle_mousemove(event.position, event.screen_position, event.buttons, event.modifiers);
-            case Web::MouseEvent::Type::MouseWheel:
-                return page->page().handle_mousewheel(event.position, event.screen_position, event.button, event.buttons, event.modifiers, event.wheel_delta_x, event.wheel_delta_y);
-            case Web::MouseEvent::Type::DoubleClick:
-                return page->page().handle_doubleclick(event.position, event.screen_position, event.button, event.buttons, event.modifiers);
-            }
-            VERIFY_NOT_REACHED();
-        },
-        [&](Web::DragEvent& event) {
-            return page->page().handle_drag_and_drop_event(event.type, event.position, event.screen_position, event.button, event.buttons, event.modifiers, move(event.files));
-        });
-
-    // We have to notify the client about coalesced events, so we do that by saying none of them were handled by the web page.
-    for (size_t i = 0; i < event.coalesced_event_count; ++i)
-        report_finished_handling_input_event(event.page_id, Web::EventResult::Dropped);
-    report_finished_handling_input_event(event.page_id, result);
-
-    if (!m_input_event_queue.is_empty())
-        m_input_event_queue_timer->start();
-}
-
 void ConnectionFromClient::key_event(u64 page_id, Web::KeyEvent const& event)
 {
     enqueue_input_event({ page_id, move(const_cast<Web::KeyEvent&>(event)), 0 });
@@ -279,15 +229,9 @@ void ConnectionFromClient::drag_event(u64 page_id, Web::DragEvent const& event)
     enqueue_input_event({ page_id, move(const_cast<Web::DragEvent&>(event)), 0 });
 }
 
-void ConnectionFromClient::enqueue_input_event(QueuedInputEvent event)
+void ConnectionFromClient::enqueue_input_event(Web::QueuedInputEvent event)
 {
     m_input_event_queue.enqueue(move(event));
-    m_input_event_queue_timer->start();
-}
-
-void ConnectionFromClient::report_finished_handling_input_event(u64 page_id, Web::EventResult event_result)
-{
-    async_did_finish_handling_input_event(page_id, event_result);
 }
 
 void ConnectionFromClient::debug_request(u64 page_id, ByteString const& request, ByteString const& argument)

Services/WebContent/ConnectionFromClient.h

@@ -47,6 +47,8 @@ public:
 
     Function<void(IPC::File const&)> on_image_decoder_connection;
 
+    Queue<Web::QueuedInputEvent>& input_event_queue() { return m_input_event_queue; }
+
 private:
     explicit ConnectionFromClient(GC::Heap&, IPC::Transport);
 
@@ -149,26 +151,15 @@ private:
 
     virtual void system_time_zone_changed() override;
 
-    void report_finished_handling_input_event(u64 page_id, Web::EventResult event_was_handled);
-
     GC::Heap& m_heap;
     NonnullOwnPtr<PageHost> m_page_host;
 
     HashMap<int, Web::FileRequest> m_requested_files {};
     int last_id { 0 };
 
-    struct QueuedInputEvent {
+    void enqueue_input_event(Web::QueuedInputEvent);
-        u64 page_id { 0 };
-        Web::InputEvent event;
-        size_t coalesced_event_count { 0 };
-    };
 
-    void enqueue_input_event(QueuedInputEvent);
+    Queue<Web::QueuedInputEvent> m_input_event_queue;
-    void process_next_input_event();
-
-    Queue<QueuedInputEvent> m_input_event_queue;
-
-    GC::Root<Web::Platform::Timer> m_input_event_queue_timer;
 };
 
 }

Services/WebContent/PageClient.cpp

@@ -223,6 +223,16 @@ void PageClient::paint(Web::DevicePixelRect const& content_rect, Web::Painting::
     page().top_level_traversable()->paint(content_rect, target, paint_options);
 }
 
+Queue<Web::QueuedInputEvent>& PageClient::input_event_queue()
+{
+    return client().input_event_queue();
+}
+
+void PageClient::report_finished_handling_input_event(u64 page_id, Web::EventResult event_was_handled)
+{
+    client().async_did_finish_handling_input_event(page_id, event_was_handled);
+}
+
 void PageClient::set_viewport_size(Web::DevicePixelSize const& size)
 {
     page().top_level_traversable()->set_viewport_size(page().device_to_css_size(size));

Services/WebContent/PageClient.h

@@ -48,6 +48,9 @@ public:
     virtual void process_screenshot_requests() override;
     virtual void paint(Web::DevicePixelRect const& content_rect, Web::Painting::BackingStore&, Web::PaintOptions = {}) override;
 
+    virtual Queue<Web::QueuedInputEvent>& input_event_queue() override;
+    virtual void report_finished_handling_input_event(u64 page_id, Web::EventResult event_was_handled) override;
+
     void set_palette_impl(Gfx::PaletteImpl&);
     void set_viewport_size(Web::DevicePixelSize const&);
     void set_screen_rects(Vector<Web::DevicePixelRect, 4> const& rects, size_t main_screen_index) { m_screen_rect = rects[main_screen_index]; }

Services/WebWorker/PageHost.h

@@ -38,6 +38,8 @@ public:
     virtual bool is_ready_to_paint() const override { return true; }
     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(); }
+    virtual void report_finished_handling_input_event([[maybe_unused]] u64 page_id, [[maybe_unused]] Web::EventResult event_was_handled) override { VERIFY_NOT_REACHED(); }
 
 private:
     explicit PageHost(ConnectionFromClient&);