Skip to content

Lightpanda: the headless browser designed for AI and automation

Dispatch every wheel through one path

Adrià Arrufatc51376edc03f
diff --git a/src/browser/EventManager.zig b/src/browser/EventManager.zig
index d6946fe67..0137b2f83 100644
--- a/src/browser/EventManager.zig
+++ b/src/browser/EventManager.zig
@@ -149,6 +149,32 @@ pub fn hasDirectListeners(self: *EventManager, target: *EventTarget, typ: []cons
return self.base.hasDirectListeners(target, typ, handler);
}
+/// Whether any listener for `typ` on the path from `node` up to the window
+/// is non-passive. The UA dispatches scroll-blocking events as
+/// non-cancelable when none is: it already knows preventDefault can't be
+/// called.
+pub fn hasNonPassiveListener(self: *EventManager, node: *Node, typ: []const u8) bool {
+ var current: ?*Node = node;
+ while (current) |n| : (current = n.parentNode()) {
+ if (anyNonPassive(self.base.getListeners(n.asEventTarget(), .wrap(typ)))) {
+ return true;
+ }
+ }
+ return anyNonPassive(self.base.getListeners(self.frame.window.asEventTarget(), .wrap(typ)));
+}
+
+fn anyNonPassive(list_: ?*std.DoublyLinkedList) bool {
+ const list = list_ orelse return false;
+ var link = list.first;
+ while (link) |l| : (link = l.next) {
+ const listener: *align(8) Listener = @fieldParentPtr("node", l);
+ if (!listener.passive) {
+ return true;
+ }
+ }
+ return false;
+}
+
fn dispatchNode(self: *EventManager, target: *Node, event: *Event) !void {
const target_et = target.asEventTarget();
event._target = target_et;
diff --git a/src/browser/frame/user_input.zig b/src/browser/frame/user_input.zig
index 32f53dfaa..82f1b7f25 100644
--- a/src/browser/frame/user_input.zig
+++ b/src/browser/frame/user_input.zig
@@ -287,22 +287,39 @@ pub fn triggerMouseWheel(frame: *Frame, x: f64, y: f64, delta_x: f64, delta_y: f
});
}
- const wheel_event: *WheelEvent = try .initTrusted("wheel", .{
- .bubbles = true,
- .cancelable = true,
- .composed = true,
- .clientX = x,
- .clientY = y,
- .deltaX = delta_x,
- .deltaY = delta_y,
- }, frame);
+ try wheel(frame, target, x, y, delta_x, delta_y);
+}
+
+/// A wheel over `target`: trusted `wheel`, the legacy `mousewheel` Blink
+/// still fires, then the scroll unless either was canceled. Each event is
+/// non-cancelable when every listener on its path is passive.
+pub fn wheel(frame: *Frame, target: *Element, x: f64, y: f64, delta_x: f64, delta_y: f64) !void {
+ // Listeners live in the event manager of the element's own frame, which
+ // is not the caller's when the element belongs to an iframe's document.
+ const owner = target.ownerFrame(frame) orelse return;
+ const event_manager = &owner._event_manager;
- if (try frame._event_manager.dispatchCancelable(target.asEventTarget(), wheel_event.asEvent())) {
+ var canceled = false;
+ inline for (.{ "wheel", "mousewheel" }) |typ| {
+ const event: *WheelEvent = try .initTrusted(typ, .{
+ .bubbles = true,
+ .cancelable = event_manager.hasNonPassiveListener(target.asNode(), typ),
+ .composed = true,
+ .clientX = x,
+ .clientY = y,
+ .deltaX = delta_x,
+ .deltaY = delta_y,
+ }, owner);
+ if (try event_manager.dispatchCancelable(target.asEventTarget(), event.asEvent())) {
+ canceled = true;
+ }
+ }
+ if (canceled) {
return;
}
- // CDP deltas are untrusted, so guard NaN and saturate the addition.
- try wheelScroll(target, deltaToScroll(delta_x), deltaToScroll(delta_y), frame);
+ // Deltas come from the wire, so guard NaN and saturate the addition.
+ try wheelScroll(target, deltaToScroll(delta_x), deltaToScroll(delta_y), owner);
}
/// Each axis scrolls the nearest ancestor-or-self scroll container along it,
diff --git a/src/browser/webapi/WebDriver.zig b/src/browser/webapi/WebDriver.zig
index df5008ca3..71c8d2e99 100644
--- a/src/browser/webapi/WebDriver.zig
+++ b/src/browser/webapi/WebDriver.zig
@@ -22,7 +22,6 @@ const lp = @import("lightpanda");
const js = @import("../js/js.zig");
const Page = @import("../Page.zig");
const Frame = @import("../Frame.zig");
-const EventManagerBase = @import("../EventManagerBase.zig");
const Modifiers = @import("../frame/user_input.zig").Modifiers;
const Event = @import("Event.zig");
@@ -32,7 +31,6 @@ const EventTarget = @import("EventTarget.zig");
const Cookie = @import("storage/Cookie.zig");
const MouseEvent = @import("event/MouseEvent.zig");
const TouchEvent = @import("event/TouchEvent.zig");
-const WheelEvent = @import("event/WheelEvent.zig");
const PointerEvent = @import("event/PointerEvent.zig");
const KeyboardEvent = @import("event/KeyboardEvent.zig");
const Label = @import("element/html/Label.zig");
@@ -588,46 +586,9 @@ fn dispatchMouse(el: *Element, comptime typ: []const u8, button: i32, buttons: u
}
fn dispatchWheel(el: *Element, delta_x: i32, delta_y: i32, frame: *Frame) void {
- // The UA dispatches scroll-blocking events as non-cancelable when every
- // listener on the propagation path is passive: it already knows
- // preventDefault can't be called.
- const event = WheelEvent.initTrusted("wheel", .{
- .bubbles = true,
- .cancelable = hasNonPassiveListener(el, "wheel", frame),
- .composed = true,
- .deltaX = @floatFromInt(delta_x),
- .deltaY = @floatFromInt(delta_y),
- }, frame) catch |err| {
- log.warn(.app, "webdriver wheel event", .{ .err = err });
- return;
- };
-
- // Keep the event alive past dispatch so we can read _prevent_default.
- event.asEvent().acquireRef();
- defer _ = event.asEvent().releaseRef(frame._page);
- dispatch(el.asEventTarget(), event.asEvent(), frame, "wheel");
-
- // Blink also fires the legacy mousewheel event.
- const legacy = WheelEvent.initTrusted("mousewheel", .{
- .bubbles = true,
- .cancelable = hasNonPassiveListener(el, "mousewheel", frame),
- .composed = true,
- .deltaX = @floatFromInt(delta_x),
- .deltaY = @floatFromInt(delta_y),
- }, frame) catch |err| {
- log.warn(.app, "webdriver mousewheel event", .{ .err = err });
- return;
- };
- legacy.asEvent().acquireRef();
- defer _ = legacy.asEvent().releaseRef(frame._page);
- dispatch(el.asEventTarget(), legacy.asEvent(), frame, "mousewheel");
-
- if (event.asEvent()._prevent_default or legacy.asEvent()._prevent_default) {
- return;
- }
-
- Frame.user_input.wheelScroll(el, delta_x, delta_y, frame) catch |err| {
- log.warn(.app, "webdriver scroll", .{ .err = err });
+ const rect = el.boundingClientRectValues(frame);
+ Frame.user_input.wheel(frame, el, rect.x, rect.y, @floatFromInt(delta_x), @floatFromInt(delta_y)) catch |err| {
+ log.warn(.app, "webdriver wheel", .{ .err = err });
};
}
@@ -637,37 +598,13 @@ fn dispatch(target: *EventTarget, event: *Event, frame: *Frame, typ: []const u8)
};
}
-fn hasNonPassiveListener(el: *Element, typ: []const u8, frame: *Frame) bool {
- // Listeners live in the event manager of the element's own frame (and the
- // propagation path ends at that frame's window), which is not the caller's
- // frame when the element belongs to e.g. an iframe's document.
- const owner = el.ownerFrame(frame) orelse return false;
- const base = &owner._event_manager.base;
- var current: ?*@import("Node.zig") = el.asNode();
- while (current) |node| : (current = node.parentNode()) {
- if (anyNonPassive(base.getListeners(node.asEventTarget(), .wrap(typ)))) {
- return true;
- }
- }
- return anyNonPassive(base.getListeners(owner.window.asEventTarget(), .wrap(typ)));
-}
-
-fn anyNonPassive(list_: ?*std.DoublyLinkedList) bool {
- const list = list_ orelse return false;
- var link = list.first;
- while (link) |l| : (link = l.next) {
- const listener: *align(8) EventManagerBase.Listener = @fieldParentPtr("node", l);
- if (!listener.passive) {
- return true;
- }
- }
- return false;
-}
-
fn dispatchTouch(el: *Element, comptime typ: []const u8, frame: *Frame) void {
+ // Listeners live in the event manager of the element's own frame, which
+ // is not the caller's when the element belongs to an iframe's document.
+ const owner = el.ownerFrame(frame) orelse return;
const event = TouchEvent.initTrusted(typ, .{
.bubbles = true,
- .cancelable = hasNonPassiveListener(el, typ, frame),
+ .cancelable = owner._event_manager.hasNonPassiveListener(el.asNode(), typ),
.composed = true,
}, frame) catch |err| {
log.warn(.app, "webdriver touch event", .{ .err = err });
diff --git a/src/server/cdp/domains/input.zig b/src/server/cdp/domains/input.zig
index ba255d35d..4f131902a 100644
--- a/src/server/cdp/domains/input.zig
+++ b/src/server/cdp/domains/input.zig
@@ -351,6 +351,58 @@ test "cdp.input: dispatchMouseEvent mouseWheel fires wheel event" {
try testing.expect(result.isTrue());
}
+test "cdp.input: dispatchMouseEvent mouseWheel cancelability follows listener passivity" {
+ var ctx = try testing.context();
+ defer ctx.deinit();
+
+ const bc = try ctx.loadBrowserContext(.{});
+ const page = try bc.session.createPage();
+ const frame = page.frame().?;
+
+ const url = "http://localhost:9582/src/browser/tests/mcp_actions.html";
+ try frame.navigate(url, .{ .reason = .address_bar, .kind = .{ .push = null } });
+ try testing.waitForPage(bc);
+
+ var ls: lp.js.Local.Scope = undefined;
+ frame.js.localScope(&ls);
+ defer ls.deinit();
+
+ var try_catch: lp.js.TryCatch = undefined;
+ try_catch.init(&ls.local);
+ defer try_catch.deinit();
+
+ // Only passive listeners: the event is non-cancelable, preventDefault is
+ // inert and the scroll happens. Blink's legacy mousewheel fires too.
+ _ = try ls.local.compileAndRun(
+ \\const box = document.getElementById('scrollbox');
+ \\box.addEventListener('wheel', (e) => { window.passiveCancelable = e.cancelable; e.preventDefault(); }, { passive: true });
+ \\box.addEventListener('mousewheel', (e) => { window.legacyDeltaY = e.deltaY; });
+ , null);
+
+ const rect_x = try (try ls.local.compileAndRun("document.getElementById('scrollbox').getBoundingClientRect().x", null)).toF64();
+ const rect_y = try (try ls.local.compileAndRun("document.getElementById('scrollbox').getBoundingClientRect().y", null)).toF64();
+
+ try ctx.processMessage(.{
+ .id = 1,
+ .method = "Input.dispatchMouseEvent",
+ .params = .{ .type = "mouseWheel", .x = rect_x, .y = rect_y, .deltaY = 40 },
+ });
+ var result = try ls.local.compileAndRun("window.passiveCancelable === false && window.legacyDeltaY === 40 && document.getElementById('scrollbox').scrollTop === 40", null);
+ try testing.expect(result.isTrue());
+
+ // A non-passive listener makes it cancelable, and preventDefault stops the scroll.
+ _ = try ls.local.compileAndRun(
+ \\document.getElementById('scrollbox').addEventListener('wheel', (e) => { window.activeCancelable = e.cancelable; e.preventDefault(); });
+ , null);
+ try ctx.processMessage(.{
+ .id = 2,
+ .method = "Input.dispatchMouseEvent",
+ .params = .{ .type = "mouseWheel", .x = rect_x, .y = rect_y, .deltaY = 40 },
+ });
+ result = try ls.local.compileAndRun("window.activeCancelable === true && document.getElementById('scrollbox').scrollTop === 40", null);
+ try testing.expect(result.isTrue());
+}
+
test "cdp.input: dispatchMouseEvent mouseWheel scrolls a scroll container, not the viewport" {
var ctx = try testing.context();
defer ctx.deinit();