Lightpanda: the headless browser designed for AI and automation
perf: memoize AXNode isIgnore for generic containers
Adrià Arrufat555415da887a
diff --git a/src/server/cdp/AXNode.zig b/src/server/cdp/AXNode.zigindex f98eb2db0..8b0447a25 100644--- a/src/server/cdp/AXNode.zig+++ b/src/server/cdp/AXNode.zig@@ -80,13 +80,14 @@ pub const Writer = struct {}fn toJSON(self: *const Writer, w: anytype) !void {+ var ignore_cache: IgnoreCache = .empty;try w.beginArray();if (self.filter != null) {- try self.walkQuery(self.root.dom, w);+ try self.walkQuery(self.root.dom, &ignore_cache, w);} else {const root = AXNode.fromNode(self.root.dom);const root_hidden = if (self.root.dom.is(DOMNode.Element)) |el| isHidden(el, self.frame, .{}) else false;- try self.writeTree(root, root_hidden, w);+ try self.writeTree(root, root_hidden, &ignore_cache, w);}return w.endArray();}@@ -116,10 +117,10 @@ pub const Writer = struct {try w.write(s);}- fn writeTree(self: *const Writer, root: AXNode, root_hidden: bool, w: anytype) !void {+ fn writeTree(self: *const Writer, root: AXNode, root_hidden: bool, ignore_cache: *IgnoreCache, w: anytype) !void {var walker: Walker = .init(root.dom);var axn = root;- var descend = try self.writeNode(self.root.id, root, false, root_hidden, w);+ var descend = try self.writeNode(self.root.id, root, false, root_hidden, ignore_cache, w);while (true) {if (descend) {if (axn.dom.is(DOMNode.Element)) |el| {@@ -154,7 +155,7 @@ pub const Writer = struct {const node = try self.registry.register(dom_node);axn = AXNode.fromNode(node.dom);- descend = try self.writeNode(node.id, axn, walker.inAriaHidden(), false, w);+ descend = try self.writeNode(node.id, axn, walker.inAriaHidden(), false, ignore_cache, w);}}@@ -490,7 +491,7 @@ pub const Writer = struct {}// write a node. returns true if children must be written.- fn writeNode(self: *const Writer, id: u32, axn: AXNode, in_aria_hidden: bool, hidden: bool, w: anytype) !bool {+ fn writeNode(self: *const Writer, id: u32, axn: AXNode, in_aria_hidden: bool, hidden: bool, ignore_cache: *IgnoreCache, w: anytype) !bool {// ignore empty textstry w.beginObject();@@ -506,7 +507,7 @@ pub const Writer = struct {try w.objectField("role");try self.writeAXValue(.{ .role = resolved.role }, w);- const ignore = axn.isIgnore(self.frame, in_aria_hidden, hidden);+ const ignore = try axn.isIgnore(self.frame, in_aria_hidden, hidden, ignore_cache);try w.objectField("ignored");try w.write(ignore);@@ -643,12 +644,12 @@ pub const Writer = struct {// Query-mode walk. Visits every node under `root` (including AX-ignored// ones, per the queryAXTree spec) and defers emission to emitMatch.- fn walkQuery(self: *const Writer, root: *DOMNode, w: anytype) !void {+ fn walkQuery(self: *const Writer, root: *DOMNode, ignore_cache: *IgnoreCache, w: anytype) !void {var walker: Walker = .init(root);var node = root;while (true) {const axn = AXNode.fromNode(node);- try self.emitMatch(axn, walker.inAriaHidden(), w);+ try self.emitMatch(axn, walker.inAriaHidden(), ignore_cache, w);// <head>, <script>, <style> never expose AX content — skip their children.var descend = !axn.ignoreChildren();@@ -665,7 +666,7 @@ pub const Writer = struct {// the queryAXTree flat-match shape: nodeId, backendDOMNodeId, ignored,// role, name, plus empty properties / childIds (clients fetch full// properties via getFullAXTree on a matched nodeId).- fn emitMatch(self: *const Writer, axn: AXNode, in_aria_hidden: bool, w: anytype) !void {+ fn emitMatch(self: *const Writer, axn: AXNode, in_aria_hidden: bool, ignore_cache: *IgnoreCache, w: anytype) !void {const filter = self.filter.?;const resolved = self.resolveRole(axn) catch return;@@ -680,7 +681,7 @@ pub const Writer = struct {const node = try self.registry.register(axn.dom);const hidden = if (axn.dom.is(DOMNode.Element)) |el| isHidden(el, self.frame, .{}) else false;- const ignored = axn.isIgnore(self.frame, in_aria_hidden, hidden);+ const ignored = try axn.isIgnore(self.frame, in_aria_hidden, hidden, ignore_cache);try w.beginObject();@@ -1358,29 +1359,57 @@ fn ignoreChildren(self: AXNode) bool {};}+// Generic containers are ignored unless a non-ignored node sits under them+// through other generic containers. Asking that of every node in a deep chain+// is quadratic, so the answers are memoized for the duration of one walk.+const IgnoreCache = std.AutoHashMapUnmanaged(*DOMNode, bool);+// `hidden` comes from the caller: the tree walk prunes, so its children never// are; the root and the query walk probe the whole chain.-fn isIgnore(self: AXNode, frame: *Frame, in_aria_hidden: bool, hidden: bool) bool {+fn isIgnore(self: AXNode, frame: *Frame, in_aria_hidden: bool, hidden: bool, cache: *IgnoreCache) !bool {return switch (self.ignoreSelf(in_aria_hidden, hidden)) {.ignored => true,.exposed => false,- // A generic container is ignored unless it has a non-ignored- // descendant, reached through other generic containers.- .generic => {- var tw = TreeWalker.FullExcludeSelf.init(self.dom, .{});- while (tw.next()) |node| {- const node_hidden = if (node.is(DOMNode.Element)) |el| isHidden(el, frame, .{ .ancestors = false }) else false;- switch (AXNode.fromNode(node).ignoreSelf(in_aria_hidden, node_hidden)) {- .ignored => tw.skipChildren(),- .exposed => return false,- .generic => {},- }- }- return true;- },+ .generic => isGenericIgnored(self.dom, frame, cache),};}+/// Only reached outside aria-hidden (ignoreSelf would have said .ignored), so+/// the answer depends on the node alone.+fn isGenericIgnored(root: *DOMNode, frame: *Frame, cache: *IgnoreCache) !bool {+ const allocator = frame.call_arena;+ if (cache.get(root)) |ignored| return ignored;+ // Every generic container the scan enters is provisionally ignored: it is+ // unless it's an ancestor of the exposed node that ends the scan.+ try cache.put(allocator, root, true);++ var tw = TreeWalker.FullExcludeSelf.init(root, .{});+ const exposed = while (tw.next()) |node| {+ const node_hidden = if (node.is(DOMNode.Element)) |el| isHidden(el, frame, .{ .ancestors = false }) else false;+ switch (AXNode.fromNode(node).ignoreSelf(false, node_hidden)) {+ .ignored => tw.skipChildren(),+ .exposed => break node,+ .generic => {+ const gop = try cache.getOrPut(allocator, node);+ if (!gop.found_existing) {+ gop.value_ptr.* = true;+ } else if (gop.value_ptr.*) {+ tw.skipChildren();+ } else {+ break node;+ }+ },+ }+ } else return true;++ var node = exposed;+ while (node != root) {+ node = node._parent.?;+ try cache.put(allocator, node, false);+ }+ return false;+}+/// isIgnore for `self` alone, leaving generic containers to the caller.fn ignoreSelf(self: AXNode, in_aria_hidden: bool, hidden: bool) enum { ignored, exposed, generic } {const node = self.dom;@@ -2085,3 +2114,33 @@ test "AXNode: writer prunes children when root is hidden" {try testing.expect(std.mem.indexOf(u8, json, "under-display-none") == null);try testing.expect(std.mem.indexOf(u8, json, "\"childIds\":[]") != null);}++test "AXNode: generic containers share memoized ignore answers" {+ var registry = NodeRegistry.init(testing.allocator);+ defer registry.deinit();++ const frame = try testing.base.createFrame();+ defer testing.base.test_session.closeAllPages();++ const root = try frame.window._document.createElement("div", null, frame);+ // Scanning #a provisionally ignores #b, #c and #d; the text under #d then+ // flips #c and #d, while #b (only a decorative image) stays ignored.+ try root.setInnerHTML(+ \\<div id="a"><div id="b"><img></div><div id="c"><span id="d">text</span></div></div>+ , frame);++ var cache: IgnoreCache = .empty;+ const expected = [_]struct { []const u8, bool }{ .{ "#a", false }, .{ "#b", true }, .{ "#c", false }, .{ "#d", false } };+ for (expected) |e| {+ const el = (try root.querySelector(e[0], frame)).?;+ try testing.expectEqual(e[1], try AXNode.fromNode(el.asNode()).isIgnore(frame, false, false, &cache));+ }+ // Every answer after #a's came from the one scan.+ try testing.expectEqual(4, cache.count());++ var fresh: IgnoreCache = .empty;+ for (expected[1..]) |e| {+ const el = (try root.querySelector(e[0], frame)).?;+ try testing.expectEqual(e[1], try AXNode.fromNode(el.asNode()).isIgnore(frame, false, false, &fresh));+ }+}