Skip to content

Lightpanda: the headless browser designed for AI and automation

internal: CDP Node / Element frame ownership

Karl Seguinb3684847a8d6
diff --git a/src/browser/tests/cdp/iframe/input_child.html b/src/browser/tests/cdp/iframe/input_child.html
new file mode 100644
index 000000000..2dfd83620
--- /dev/null
+++ b/src/browser/tests/cdp/iframe/input_child.html
@@ -0,0 +1,8 @@
+<!doctype html>
+<input id=text>
+<input id=upload type=file>
+<script>
+ window.__evts = [];
+ const rec = (e) => window.__evts.push(e.type + ':' + e.target.id);
+ for (const t of ['focus', 'focusin', 'input', 'change']) document.addEventListener(t, rec, true);
+</script>
diff --git a/src/browser/tests/cdp/input_iframe.html b/src/browser/tests/cdp/input_iframe.html
new file mode 100644
index 000000000..26073f6ab
--- /dev/null
+++ b/src/browser/tests/cdp/input_iframe.html
@@ -0,0 +1,3 @@
+<!doctype html>
+<input id=text>
+<iframe src="iframe/input_child.html"></iframe>
diff --git a/src/browser/tests/frames/cross_realm_focus.html b/src/browser/tests/frames/cross_realm_focus.html
index 3bbef9091..acd9f126d 100644
--- a/src/browser/tests/frames/cross_realm_focus.html
+++ b/src/browser/tests/frames/cross_realm_focus.html
@@ -30,4 +30,35 @@ element; we don't model that, so this file deliberately doesn't assert it.)
testing.expectEqual(idoc.body, idoc.activeElement);
});
</script>
+
+<script id="events_fire_in_own_frame">
+ testing.onload(() => {
+ const idf = document.getElementById('idf');
+ const iwin = idf.contentWindow;
+ const inp = idf.contentDocument.getElementById('fin2');
+ iwin.events.length = 0;
+
+ // The parent realm's focus/blur still dispatch through the iframe's
+ // EventManager, so its listeners see FocusEvents of the iframe's realm.
+ HTMLElement.prototype.focus.call(inp);
+ HTMLElement.prototype.blur.call(inp);
+ testing.expectEqual(
+ 'focus:fin2:true,focusin:fin2:true,blur:fin2:true,focusout:fin2:true',
+ iwin.events.join(','));
+ });
+</script>
+
+<script id="frameless_document_is_not_focusable">
+ testing.onload(() => {
+ const doc = new DOMParser().parseFromString('<input id=x>', 'text/html');
+ const inp = doc.getElementById('x');
+ let fired = 0;
+ inp.addEventListener('focus', () => fired++);
+
+ inp.focus();
+ inp.blur();
+ testing.expectEqual(0, fired);
+ testing.expectFalse(doc.activeElement === inp);
+ });
+</script>
</body>
diff --git a/src/browser/tests/frames/support/cross_realm_focus.html b/src/browser/tests/frames/support/cross_realm_focus.html
index fc23568f7..4993b7691 100644
--- a/src/browser/tests/frames/support/cross_realm_focus.html
+++ b/src/browser/tests/frames/support/cross_realm_focus.html
@@ -3,4 +3,13 @@
<body>
<input id="fin">
<input id="fin2">
+ <script>
+ // Listeners live in this frame's realm; the parent reads `events` back.
+ window.events = [];
+ for (const t of ['focus', 'focusin', 'blur', 'focusout']) {
+ document.addEventListener(t, (e) => {
+ window.events.push(`${e.type}:${e.target.id}:${e instanceof FocusEvent}`);
+ }, true);
+ }
+ </script>
</body>
diff --git a/src/browser/webapi/Element.zig b/src/browser/webapi/Element.zig
index ddb480267..f3a644b45 100644
--- a/src/browser/webapi/Element.zig
+++ b/src/browser/webapi/Element.zig
@@ -1222,7 +1222,8 @@ pub fn focus(self: *Element, frame: *Frame) !void {
return;
}
- const doc = self.asNode().ownerDocument(frame) orelse frame.document;
+ const owner = self.ownerFrame(frame) orelse return;
+ const doc = owner.document;
const old_active = doc._active_element;
if (old_active == self) {
return;
@@ -1230,54 +1231,56 @@ pub fn focus(self: *Element, frame: *Frame) !void {
// Per HTML spec §6.4.4, an element must be "being rendered" (not
// display:none on self or any ancestor) to be focusable.
- if (!self.isVisible(frame)) {
+ if (!self.isVisible(owner)) {
return;
}
const FocusEvent = @import("event/FocusEvent.zig");
const new_target = self.asEventTarget();
- doc.setActiveElement(self, frame);
+ doc.setActiveElement(self, owner);
if (old_active) |old| {
const old_target = old.asEventTarget();
// Dispatch blur on old element (no bubble, composed)
- const blur_event = try FocusEvent.initTrusted(comptime .wrap("blur"), .{ .composed = true, .relatedTarget = new_target }, frame);
- try frame._event_manager.dispatch(old_target, blur_event.asEvent());
+ const blur_event = try FocusEvent.initTrusted(comptime .wrap("blur"), .{ .composed = true, .relatedTarget = new_target }, owner);
+ try owner._event_manager.dispatch(old_target, blur_event.asEvent());
// Dispatch focusout on old element (bubbles, composed)
- const focusout_event = try FocusEvent.initTrusted(comptime .wrap("focusout"), .{ .bubbles = true, .composed = true, .relatedTarget = new_target }, frame);
- try frame._event_manager.dispatch(old_target, focusout_event.asEvent());
+ const focusout_event = try FocusEvent.initTrusted(comptime .wrap("focusout"), .{ .bubbles = true, .composed = true, .relatedTarget = new_target }, owner);
+ try owner._event_manager.dispatch(old_target, focusout_event.asEvent());
}
const old_related: ?*EventTarget = if (old_active) |old| old.asEventTarget() else null;
// Dispatch focus on new element (no bubble, composed)
- const focus_event = try FocusEvent.initTrusted(comptime .wrap("focus"), .{ .composed = true, .relatedTarget = old_related }, frame);
- try frame._event_manager.dispatch(new_target, focus_event.asEvent());
+ const focus_event = try FocusEvent.initTrusted(comptime .wrap("focus"), .{ .composed = true, .relatedTarget = old_related }, owner);
+ try owner._event_manager.dispatch(new_target, focus_event.asEvent());
// Dispatch focusin on new element (bubbles, composed)
- const focusin_event = try FocusEvent.initTrusted(comptime .wrap("focusin"), .{ .bubbles = true, .composed = true, .relatedTarget = old_related }, frame);
- try frame._event_manager.dispatch(new_target, focusin_event.asEvent());
+ const focusin_event = try FocusEvent.initTrusted(comptime .wrap("focusin"), .{ .bubbles = true, .composed = true, .relatedTarget = old_related }, owner);
+ try owner._event_manager.dispatch(new_target, focusin_event.asEvent());
}
pub fn blur(self: *Element, frame: *Frame) !void {
- const doc = self.asNode().ownerDocument(frame) orelse frame.document;
+ // A frameless document never has a focused element.
+ const owner = self.ownerFrame(frame) orelse return;
+ const doc = owner.document;
if (doc._active_element != self) return;
- doc.setActiveElement(null, frame);
+ doc.setActiveElement(null, owner);
const FocusEvent = @import("event/FocusEvent.zig");
const old_target = self.asEventTarget();
// Dispatch blur (no bubble, composed)
- const blur_event = try FocusEvent.initTrusted(comptime .wrap("blur"), .{ .composed = true }, frame);
- try frame._event_manager.dispatch(old_target, blur_event.asEvent());
+ const blur_event = try FocusEvent.initTrusted(comptime .wrap("blur"), .{ .composed = true }, owner);
+ try owner._event_manager.dispatch(old_target, blur_event.asEvent());
// Dispatch focusout (bubbles, composed)
- const focusout_event = try FocusEvent.initTrusted(comptime .wrap("focusout"), .{ .bubbles = true, .composed = true }, frame);
- try frame._event_manager.dispatch(old_target, focusout_event.asEvent());
+ const focusout_event = try FocusEvent.initTrusted(comptime .wrap("focusout"), .{ .bubbles = true, .composed = true }, owner);
+ try owner._event_manager.dispatch(old_target, focusout_event.asEvent());
}
pub fn getChildren(self: *Element, frame: *Frame) !collections.NodeLive(.child_elements) {
diff --git a/src/server/cdp/CDP.zig b/src/server/cdp/CDP.zig
index 24739794f..b7e0d560e 100644
--- a/src/server/cdp/CDP.zig
+++ b/src/server/cdp/CDP.zig
@@ -716,8 +716,8 @@ pub const BrowserContext = struct {
// (`Label.findLabelByFor` against `ownerDocument`) and visibility
// checks (`frame._style_manager`) are per-frame; getting this wrong on
// cross-frame queries produces names/visibility from the wrong document.
- const fallback = self.mainFrame() orelse return error.FrameNotLoaded;
- const frame = root.dom.ownerFrame(fallback) orelse fallback;
+ const main_frame = self.mainFrame() orelse return error.FrameNotLoaded;
+ const frame = root.dom.ownerFrame(main_frame) orelse return error.InvalidNodeId;
const label_index = try frame.call_arena.create(Label.LabelByForIndex);
label_index.* = .{};
return .{
diff --git a/src/server/cdp/domains/accessibility.zig b/src/server/cdp/domains/accessibility.zig
index 2bdda6aa5..9d46d796d 100644
--- a/src/server/cdp/domains/accessibility.zig
+++ b/src/server/cdp/domains/accessibility.zig
@@ -194,3 +194,42 @@ test "cdp.accessibility: getPartialAXTree with unknown nodeId returns error" {
});
try ctx.expectSentError(-31998, "NodeNotFound", .{ .id = 1 });
}
+
+test "cdp.accessibility: getPartialAXTree rejects a frameless node" {
+ var ctx = try testing.context();
+ defer ctx.deinit();
+
+ _ = try ctx.loadBrowserContext(.{ .id = "BID-A", .url = "cdp/ax_tree.html" });
+
+ try ctx.processMessage(.{ .id = 1, .method = "Runtime.evaluate", .params = .{
+ .expression = "new DOMParser().parseFromString('<button>b</button>', 'text/html').body",
+ } });
+ const object_id = try evaluatedObjectId(&ctx, 1);
+
+ try ctx.processMessage(.{
+ .id = 2,
+ .method = "Accessibility.getPartialAXTree",
+ .params = .{ .objectId = object_id, .fetchRelatives = false },
+ });
+ try ctx.expectSentError(-31998, "InvalidNodeId", .{ .id = 2 });
+}
+
+// The result.result.objectId of the Runtime.evaluate response to `msg_id`.
+fn evaluatedObjectId(ctx: *testing.TestContext, msg_id: i64) ![]const u8 {
+ var i: usize = 0;
+ while (try ctx.getSentMessage(i)) |msg| : (i += 1) {
+ const obj = switch (msg) {
+ .object => |o| o,
+ else => continue,
+ };
+ const id_value = obj.get("id") orelse continue;
+ if (id_value != .integer or id_value.integer != msg_id) {
+ continue;
+ }
+ const result = obj.get("result") orelse return error.NoResult;
+ const remote = result.object.get("result") orelse return error.NoRemoteObject;
+ const object_id = remote.object.get("objectId") orelse return error.NoObjectId;
+ return object_id.string;
+ }
+ return error.MessageNotFound;
+}
diff --git a/src/server/cdp/domains/dom.zig b/src/server/cdp/domains/dom.zig
index 0861216ec..52ef57eff 100644
--- a/src/server/cdp/domains/dom.zig
+++ b/src/server/cdp/domains/dom.zig
@@ -358,7 +358,8 @@ fn resolveNode(cmd: *CDP.Command) !void {
const js_context = if (params.executionContextId) |context_id|
findContext(bc, root, context_id) orelse return error.ContextNotFound
else
- nodeFrame(node.dom, root).js;
+ // orelse root is safe here since there's no frame-specific state being used
+ (node.dom.ownerFrame(root) orelse root).js;
var ls: js.Local.Scope = undefined;
js_context.localScope(&ls);
@@ -383,16 +384,6 @@ fn resolveNode(cmd: *CDP.Command) !void {
} }, .{});
}
-// The frame owning the node's document. Synthetic documents (DOMParser,
-// DOMImplementation) have no frame and fall back to the root.
-fn nodeFrame(dom_node: *DOMNode, root: *Frame) *Frame {
- const document = if (dom_node._type == .document)
- dom_node.subtype(DOMNode.Document)
- else
- dom_node.ownerDocument(root) orelse return root;
- return document._frame orelse root;
-}
-
// The context the inspector announced under `context_id`: any frame's main
// world, then any isolated world's per-frame contexts.
fn findContext(bc: *CDP.BrowserContext, root: *Frame, context_id: u32) ?*js.Context {
@@ -661,12 +652,14 @@ fn setFileInputFiles(cmd: *CDP.Command) !void {
})) orelse return error.InvalidParams;
const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
- const frame = bc.mainFrame() orelse return error.FrameNotLoaded;
+ const root = bc.mainFrame() orelse return error.FrameNotLoaded;
const node = try getNode(cmd.arena, bc, params.nodeId, params.backendNodeId, params.objectId);
const element = node.dom.is(DOMNode.Element) orelse return error.NodeIsNotAnElement;
const input = element.is(Input) orelse return error.NotAnInputElement;
if (input._input_type != .file) return error.NotAFileInput;
+ // input/change fire through the owner frame's EventManager.
+ const frame = element.ownerFrame(root) orelse return error.InvalidNodeId;
var files = try cmd.arena.alloc(*File, params.files.len);
{
@@ -1152,6 +1145,49 @@ test "cdp.dom: setFileInputFiles errors when a path is missing" {
try ctx.expectSentError(-31998, "FileNotFound", .{ .id = 3 });
}
+test "cdp.dom: focus and setFileInputFiles fire in the node's own frame" {
+ var ctx = try testing.context();
+ defer ctx.deinit();
+
+ const bc = try ctx.loadBrowserContext(.{ .id = "BID-A", .url = "cdp/input_iframe.html" });
+ const child = bc.mainFrame().?.child_frames.items[0];
+
+ const text = child.document.getElementById("text", child) orelse unreachable;
+ const upload = child.document.getElementById("upload", child) orelse unreachable;
+ const text_node = try bc.node_registry.register(text.asNode());
+ const upload_node = try bc.node_registry.register(upload.asNode());
+
+ try std.Io.Dir.cwd().createDirPath(lp.io, ".zig-cache/tmp");
+ var tmp_dir = try std.Io.Dir.cwd().openDir(lp.io, ".zig-cache/tmp", .{});
+ defer tmp_dir.close(lp.io);
+ {
+ const f = try tmp_dir.createFile(lp.io, "upload.txt", .{ .truncate = true });
+ defer f.close(lp.io);
+ try f.writeStreamingAll(lp.io, "hello upload");
+ }
+
+ try ctx.processMessage(.{ .id = 1, .method = "DOM.focus", .params = .{ .nodeId = text_node.id } });
+ try ctx.expectSentResult(null, .{ .id = 1 });
+ try ctx.processMessage(.{
+ .id = 2,
+ .method = "DOM.setFileInputFiles",
+ .params = .{
+ .nodeId = upload_node.id,
+ .files = &[_][]const u8{".zig-cache/tmp/upload.txt"},
+ },
+ });
+ try ctx.expectSentResult(null, .{ .id = 2 });
+
+ // The child's listeners only see events dispatched through its own frame.
+ var ls: lp.js.Local.Scope = undefined;
+ child.js.localScope(&ls);
+ defer ls.deinit();
+ const result = try ls.local.compileAndRun(
+ \\window.__evts.join(',') === 'focus:text,focusin:text,input:upload,change:upload'
+ , null);
+ try testing.expect(result.isTrue());
+}
+
test "cdp.dom: isXPathQuery heuristic" {
// XPath-shaped queries — each line covers a distinct heuristic branch.
try std.testing.expect(isXPathQuery("/html"));