Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: bound element scroll task allocations

Francis Bouvier8f42b72d18ce
diff --git a/src/browser/tests/window_scroll.html b/src/browser/tests/window_scroll.html
index d5a5c0100..0aff32cad 100644
--- a/src/browser/tests/window_scroll.html
+++ b/src/browser/tests/window_scroll.html
@@ -34,3 +34,52 @@
testing.expectEqual(0, window.scrollX);
testing.expectEqual(0, window.scrollY);
</script>
+
+<script id=element_scroll_events_coalesce_and_preserve_reentrancy type=module>
+ const state = await testing.async();
+ const element = document.createElement('div');
+ let scrolls = 0;
+ let scrollends = 0;
+
+ element.addEventListener('scroll', () => {
+ scrolls++;
+ if (scrolls === 1) {
+ element.scrollTop = 101;
+ }
+ });
+ element.addEventListener('scrollend', () => {
+ scrollends++;
+ if (scrollends === 1) {
+ element.scrollTop = 102;
+ }
+ });
+
+ for (let i = 1; i <= 100; i++) {
+ element.scrollTop = i;
+ }
+ await new Promise(resolve => setTimeout(resolve, 100));
+
+ state.resolve();
+ await state.done(() => {
+ testing.expectEqual(3, scrolls);
+ testing.expectEqual(2, scrollends);
+ });
+</script>
+
+<script id=element_scrollBy_noop_does_not_fire_events type=module>
+ const state = await testing.async();
+ const element = document.createElement('div');
+ let scrolls = 0;
+ let scrollends = 0;
+
+ element.addEventListener('scroll', () => scrolls++);
+ element.addEventListener('scrollend', () => scrollends++);
+ element.scrollBy(-1, -1);
+ await new Promise(resolve => setTimeout(resolve, 50));
+
+ state.resolve();
+ await state.done(() => {
+ testing.expectEqual(0, scrolls);
+ testing.expectEqual(0, scrollends);
+ });
+</script>
diff --git a/src/browser/webapi/Element.zig b/src/browser/webapi/Element.zig
index c6c236141..4e52cfe53 100644
--- a/src/browser/webapi/Element.zig
+++ b/src/browser/webapi/Element.zig
@@ -1693,9 +1693,11 @@ pub fn scrollBy(self: *Element, opts: ?ScrollToOpts, y: ?i32, frame: *Frame) !vo
.x => |x| .{ x, y orelse 0 },
.opts => |dict| .{ dict.left orelse 0, dict.top orelse 0 },
};
+ const old_x = gop.value_ptr.x;
+ const old_y = gop.value_ptr.y;
gop.value_ptr.x = @intCast(@max(0, @as(i32, @intCast(gop.value_ptr.x)) + dx));
gop.value_ptr.y = @intCast(@max(0, @as(i32, @intCast(gop.value_ptr.y)) + dy));
- if (dx != 0 or dy != 0) {
+ if (gop.value_ptr.x != old_x or gop.value_ptr.y != old_y) {
try self.scheduleScrollEvents(owner);
}
}
@@ -1709,91 +1711,84 @@ fn scheduleScrollEvents(self: *Element, frame: *Frame) !void {
if (!gop.found_existing) {
gop.value_ptr.* = .{};
}
+ const task_pending = gop.value_ptr.state != .done;
gop.value_ptr.state = .scroll;
+ if (task_pending) {
+ return;
+ }
const task = try frame._factory.create(ScrollEventTask{ .frame = frame, .element = self });
- try frame.js.scheduler.add(task, ScrollEventTask.dispatchScroll, 10, .{ .low_priority = true });
- try frame.js.scheduler.add(task, ScrollEventTask.dispatchScrollEnd, 20, .{ .low_priority = true, .finalizer = ScrollEventTask.cancelled });
+ errdefer {
+ gop.value_ptr.state = .done;
+ frame._factory.destroy(task);
+ }
+ try frame.js.scheduler.add(task, ScrollEventTask.run, 10, .{
+ .name = "element.scrollEvents",
+ .low_priority = true,
+ .finalizer = ScrollEventTask.cancelled,
+ });
}
const ScrollEventTask = struct {
frame: *Frame,
element: *Element,
- fn cancelled(ctx: *anyopaque) void {
- const self: *ScrollEventTask = @ptrCast(@alignCast(ctx));
- self.deinit();
+ fn eventTarget(self: *ScrollEventTask) *@import("EventTarget.zig") {
+ if (self.frame.document.getDocumentElement() == self.element) {
+ return self.frame.document.asEventTarget();
+ }
+ return self.element.asEventTarget();
}
- fn deinit(self: *ScrollEventTask) void {
- self.frame._factory.destroy(self);
+ // Scroll events fired at an element don't bubble; only document-level
+ // scrolls (the scrolling element, dispatched at the document) do.
+ fn bubbles(self: *ScrollEventTask) bool {
+ return self.frame.document.getDocumentElement() == self.element;
}
- fn dispatchScroll(ctx: *anyopaque) anyerror!?u32 {
- const self: *ScrollEventTask = @ptrCast(@alignCast(ctx));
- const f = self.frame;
- const pos = f._element_scroll_positions.getPtr(self.element) orelse return null;
- if (pos.state != .scroll) {
- return null;
- }
-
- const Event = @import("Event.zig");
- const event = try Event.initTrusted(comptime .wrap("scroll"), .{ .bubbles = self.bubbles() }, f._page);
- try f._event_manager.dispatch(self.eventTarget(), event);
-
- // can't use gop on _element_scroll_positions above, since the JS callback
- // can mutate _element_scroll_positions and invalidate any pointers
- if (f._element_scroll_positions.getPtr(self.element)) |p| {
- p.state = .end;
+ fn cancelled(ptr: *anyopaque) void {
+ const self: *ScrollEventTask = @ptrCast(@alignCast(ptr));
+ if (self.frame._element_scroll_positions.getPtr(self.element)) |pos| {
+ pos.state = .done;
}
- return null;
+ self.frame._factory.destroy(self);
}
- fn dispatchScrollEnd(ctx: *anyopaque) anyerror!?u32 {
- const self: *ScrollEventTask = @ptrCast(@alignCast(ctx));
-
+ fn run(ptr: *anyopaque) anyerror!?u32 {
+ const self: *ScrollEventTask = @ptrCast(@alignCast(ptr));
const f = self.frame;
const pos = f._element_scroll_positions.getPtr(self.element) orelse {
- self.deinit();
+ f._factory.destroy(self);
return null;
};
-
switch (pos.state) {
- // The scroll event is still pending; retry in 10ms. Must not destroy
- // the task here — the entry is re-scheduled and runs again.
- .scroll => return 10,
- .end => {},
+ .scroll => {
+ pos.state = .end;
+ self.dispatchEvent(comptime .wrap("scroll"));
+ return 10;
+ },
+ .end => {
+ pos.state = .done;
+ defer f._factory.destroy(self);
+ self.dispatchEvent(comptime .wrap("scrollend"));
+ return null;
+ },
.done => {
- self.deinit();
+ f._factory.destroy(self);
return null;
},
}
-
- defer self.deinit();
- const Event = @import("Event.zig");
- const event = try Event.initTrusted(comptime .wrap("scrollend"), .{ .bubbles = self.bubbles() }, f._page);
- try f._event_manager.dispatch(self.eventTarget(), event);
-
- // can't use gop on _element_scroll_positions above, since the JS callback
- // can mutate _element_scroll_positions and invalidate any pointers
- if (f._element_scroll_positions.getPtr(self.element)) |p| {
- p.state = .done;
- }
-
- return null;
- }
-
- fn eventTarget(self: *ScrollEventTask) *EventTarget {
- if (self.frame.document.getDocumentElement() == self.element) {
- return self.frame.document.asEventTarget();
- }
- return self.element.asEventTarget();
}
- // Scroll events fired at an element don't bubble; only document-level
- // scrolls (the scrolling element, dispatched at the document) do.
- fn bubbles(self: *ScrollEventTask) bool {
- return self.frame.document.getDocumentElement() == self.element;
+ fn dispatchEvent(self: *ScrollEventTask, comptime event_type: String) void {
+ const Event = @import("Event.zig");
+ const event = Event.initTrusted(event_type, .{ .bubbles = self.bubbles() }, self.frame._page) catch |err| {
+ log.warn(.dom, "element.scroll.event", .{ .err = err });
+ return;
+ };
+ self.frame._event_manager.dispatch(self.eventTarget(), event) catch |err| {
+ log.warn(.dom, "element.scroll.dispatch", .{ .err = err });
+ };
}
};