Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: implement NodeIterator pre-removing steps

Francis Bouvier20df3d582081
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index 23b7122cc..31d25fa9c 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -51,6 +51,7 @@ const Performance = @import("webapi/Performance.zig");
const Screen = @import("webapi/Screen.zig");
const VisualViewport = @import("webapi/VisualViewport.zig");
const AbstractRange = @import("webapi/AbstractRange.zig");
+const DOMNodeIterator = @import("webapi/DOMNodeIterator.zig");
const Worker = @import("webapi/Worker.zig");
const CSSStyleSheet = @import("webapi/css/CSSStyleSheet.zig");
const CustomElementDefinition = @import("webapi/CustomElementDefinition.zig");
@@ -189,6 +190,9 @@ _http_owner: HttpClient.Owner = .{},
// List of active live ranges (for mutation updates per DOM spec)
_live_ranges: std.DoublyLinkedList = .{},
+// Live NodeIterators for the DOM pre-removing steps. Iterators are
+// slab-allocated (frame lifetime) and never unlinked.
+_live_node_iterators: std.DoublyLinkedList = .{},
// List of open BroadcastChannels, used to route postMessage between same-named
// channels in this frame's origin
@@ -2379,6 +2383,15 @@ const RemoveNodeOpts = struct {
notify_observers: bool = true,
};
pub fn removeNode(self: *Frame, parent: *Node, child: *Node, opts: RemoveNodeOpts) void {
+ // NodeIterator pre-removing steps must run while the tree is intact.
+ if (self._live_node_iterators.first != null) {
+ var it: ?*std.DoublyLinkedList.Node = self._live_node_iterators.first;
+ while (it) |link| : (it = link.next) {
+ const iterator: *DOMNodeIterator = @fieldParentPtr("_iterator_link", link);
+ iterator.nodeWillBeRemoved(child);
+ }
+ }
+
// Capture siblings before removing
const previous_sibling = child.previousSibling();
const next_sibling = child.nextSibling();
diff --git a/src/browser/webapi/DOMNodeIterator.zig b/src/browser/webapi/DOMNodeIterator.zig
index 6d23cefd1..818dc3d2d 100644
--- a/src/browser/webapi/DOMNodeIterator.zig
+++ b/src/browser/webapi/DOMNodeIterator.zig
@@ -16,6 +16,7 @@
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
+const std = @import("std");
const lp = @import("lightpanda");
const js = @import("../js/js.zig");
@@ -35,16 +36,55 @@ _filter: NodeFilter,
_reference_node: *Node,
_pointer_before_reference_node: bool,
_active: bool = false,
+// Intrusive link for Frame._live_node_iterators (pre-removing steps).
+// Iterators are slab-allocated and live as long as the frame, so they are
+// never unlinked.
+_iterator_link: std.DoublyLinkedList.Node = .{},
pub fn init(root: *Node, what_to_show: u32, filter: ?FilterOpts, frame: *Frame) !*DOMNodeIterator {
const node_filter = try NodeFilter.init(filter);
- return frame._factory.create(DOMNodeIterator{
+ const iterator = try frame._factory.create(DOMNodeIterator{
._root = root,
._filter = node_filter,
._reference_node = root,
._what_to_show = what_to_show,
._pointer_before_reference_node = true,
});
+ frame._live_node_iterators.append(&iterator._iterator_link);
+ return iterator;
+}
+
+// DOM "node iterator pre-removing steps", run while the tree still contains
+// to_be_removed.
+pub fn nodeWillBeRemoved(self: *DOMNodeIterator, to_be_removed: *Node) void {
+ // Removing the root or one of its ancestors leaves the iterator alone.
+ if (to_be_removed == self._root or to_be_removed.contains(self._root)) return;
+ if (to_be_removed != self._reference_node and !to_be_removed.contains(self._reference_node)) return;
+
+ if (self._pointer_before_reference_node) {
+ // The first node following to_be_removed's subtree, if any.
+ var node = to_be_removed;
+ while (true) {
+ if (node.nextSibling()) |sibling| {
+ self._reference_node = sibling;
+ return;
+ }
+ node = node.parentNode() orelse break;
+ }
+ self._pointer_before_reference_node = false;
+ }
+
+ // The node immediately preceding to_be_removed in tree order: the
+ // previous sibling's last inclusive descendant, or the parent.
+ if (to_be_removed.previousSibling()) |prev| {
+ var node = prev;
+ while (node.lastChild()) |child| {
+ node = child;
+ }
+ self._reference_node = node;
+ } else {
+ self._reference_node = to_be_removed.parentNode() orelse self._root;
+ }
}
pub fn deinit(self: *DOMNodeIterator, page: *Page) void {