fergalmoran/ladybird
1
0
Fork 0
mirror of https://github.com/fergalmoran/ladybird.git synced 2025-12-22 09:19:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

LibWeb: Schedule input event processing on HTML event loop

Browse Source 
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.
This commit is contained in:
Aliaksandr Kalenik
2025-02-14 23:25:12 +01:00
committed by Andreas Kling
parent 9072a7caef
commit d3c481f71a
10 changed files with 90 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
Services/WebContent/ConnectionFromClient.cpp
View File

@@ -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)

17
Services/WebContent/ConnectionFromClient.h
View File

@@ -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 {
u64 page_id { 0 };
Web::InputEvent event;
size_t coalesced_event_count { 0 };
};
void enqueue_input_event(Web::QueuedInputEvent);
void enqueue_input_event(QueuedInputEvent);
void process_next_input_event();
Queue<QueuedInputEvent> m_input_event_queue;
GC::Root<Web::Platform::Timer> m_input_event_queue_timer;
Queue<Web::QueuedInputEvent> m_input_event_queue;
};
}

10
Services/WebContent/PageClient.cpp
View File

@@ -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));

3
Services/WebContent/PageClient.h
View File

@@ -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]; }