Add CDP Node Registry

This expands on the existing CDP node work used in  DOM.search. It introduces
a node registry to track all nodes returned to the client and give lookups to
get a node from a Id or a *parser.node.

Eventually, the goal is to have the Registry emit the DOM.setChildNodes event
whenever necessary, as well as support many of the missing DOM actions.

Added tests to existing search handlers. Reworked search a little bit to avoid
some unnecessary allocations and to hook it into the registry.

The generated Node is currently incomplete. The parentId is missing, the
children are missing. Also, we still need to associate the v8 ObjectId to the
node.

Finally, I moved all action handlers into a nested "domain" folder.

Author: karlseguin

src/cdp/Node.zig

@@ -0,0 +1,385 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <[email protected]>
+// Pierre Tachoire <[email protected]>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// 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 parser = @import("netsurf");
+const Allocator = std.mem.Allocator;
+
+pub const Id = u32;
+
+const Node = @This();
+
+id: Id,
+parent_id: ?Id = null,
+node_type: u32,
+backend_node_id: Id,
+node_name: []const u8,
+local_name: []const u8,
+node_value: []const u8,
+child_node_count: u32,
+children: []const *Node,
+document_url: ?[]const u8,
+base_url: ?[]const u8,
+xml_version: []const u8,
+compatibility_mode: CompatibilityMode,
+is_scrollable: bool,
+_node: *parser.Node,
+
+const CompatibilityMode = enum {
+    NoQuirksMode,
+};
+
+pub fn jsonStringify(self: *const Node, writer: anytype) !void {
+    try writer.beginObject();
+    try writer.objectField("nodeId");
+    try writer.write(self.id);
+
+    try writer.objectField("parentId");
+    try writer.write(self.parent_id);
+
+    try writer.objectField("backendNodeId");
+    try writer.write(self.backend_node_id);
+
+    try writer.objectField("nodeType");
+    try writer.write(self.node_type);
+
+    try writer.objectField("nodeName");
+    try writer.write(self.node_name);
+
+    try writer.objectField("localName");
+    try writer.write(self.local_name);
+
+    try writer.objectField("nodeValue");
+    try writer.write(self.node_value);
+
+    try writer.objectField("childNodeCount");
+    try writer.write(self.child_node_count);
+
+    try writer.objectField("children");
+    try writer.write(self.children);
+
+    try writer.objectField("documentURL");
+    try writer.write(self.document_url);
+
+    try writer.objectField("baseURL");
+    try writer.write(self.base_url);
+
+    try writer.objectField("xmlVersion");
+    try writer.write(self.xml_version);
+
+    try writer.objectField("compatibilityMode");
+    try writer.write(self.compatibility_mode);
+
+    try writer.objectField("isScrollable");
+    try writer.write(self.is_scrollable);
+    try writer.endObject();
+}
+
+// Whenever we send a node to the client, we register it here for future lookup.
+// We maintain a node -> id and id -> node lookup.
+pub const Registry = struct {
+    node_id: u32,
+    allocator: Allocator,
+    node_pool: std.heap.MemoryPool(Node),
+    lookup_by_id: std.AutoHashMapUnmanaged(Id, *Node),
+    lookup_by_node: std.HashMapUnmanaged(*parser.Node, *Node, NodeContext, std.hash_map.default_max_load_percentage),
+
+    pub fn init(allocator: Allocator) Registry {
+        return .{
+            .node_id = 0,
+            .allocator = allocator,
+            .lookup_by_id = .{},
+            .lookup_by_node = .{},
+            .node_pool = std.heap.MemoryPool(Node).init(allocator),
+        };
+    }
+
+    pub fn deinit(self: *Registry) void {
+        const allocator = self.allocator;
+        self.lookup_by_id.deinit(allocator);
+        self.lookup_by_node.deinit(allocator);
+        self.node_pool.deinit();
+    }
+
+    pub fn reset(self: *Registry) void {
+        self.lookup_by_id.clearRetainingCapacity();
+        self.lookup_by_node.clearRetainingCapacity();
+        _ = self.node_pool.reset(.{ .retain_capacity = {} });
+    }
+
+    pub fn register(self: *Registry, n: *parser.Node) !*Node {
+        const node_lookup_gop = try self.lookup_by_node.getOrPut(self.allocator, n);
+        if (node_lookup_gop.found_existing) {
+            return node_lookup_gop.value_ptr.*;
+        }
+
+        // on error, we're probably going to abort the entire browser context
+        // but, just in case, let's try to keep things tidy.
+        errdefer _ = self.lookup_by_node.remove(n);
+
+        const children = try parser.nodeGetChildNodes(n);
+        const children_count = try parser.nodeListLength(children);
+
+        const id = self.node_id;
+        defer self.node_id = id + 1;
+
+        const node = try self.node_pool.create();
+        errdefer self.node_pool.destroy(node);
+
+        node.* = .{
+            ._node = n,
+            .id = id,
+            .parent_id = null, // TODO
+            .backend_node_id = id, // ??
+            .node_name = try parser.nodeName(n),
+            .local_name = try parser.nodeLocalName(n),
+            .node_value = try parser.nodeValue(n) orelse "",
+            .node_type = @intFromEnum(try parser.nodeType(n)),
+            .child_node_count = children_count,
+            .children = &.{}, // TODO
+            .document_url = null,
+            .base_url = null,
+            .xml_version = "",
+            .compatibility_mode = .NoQuirksMode,
+            .is_scrollable = false,
+        };
+
+        // if (try parser.nodeParentNode(n)) |pn| {
+        //     _  = pn;
+        //     // TODO
+        // }
+
+        node_lookup_gop.value_ptr.* = node;
+        try self.lookup_by_id.putNoClobber(self.allocator, id, node);
+        return node;
+    }
+};
+
+const NodeContext = struct {
+    pub fn hash(_: NodeContext, n: *parser.Node) u64 {
+        return std.hash.Wyhash.hash(0, std.mem.asBytes(&@intFromPtr(n)));
+    }
+
+    pub fn eql(_: NodeContext, a: *parser.Node, b: *parser.Node) bool {
+        return @intFromPtr(a) == @intFromPtr(b);
+    }
+};
+
+// Searches are a 3 step process:
+// 1 - Dom.performSearch
+// 2 - Dom.getSearchResults
+// 3 - Dom.discardSearchResults
+//
+// For a given browser context, we can have multiple active searches. I.e.
+// performSearch could be called multiple times without getSearchResults or
+// discardSearchResults being called. We keep these active searches in the
+// browser context's node_search_list, which is a SearchList. Since we don't
+// expect many active searches (mostly just 1), a list is fine to scan through.
+pub const Search = struct {
+    name: []const u8,
+    node_ids: []const Id,
+
+    pub const List = struct {
+        registry: *Registry,
+        search_id: u16 = 0,
+        arena: std.heap.ArenaAllocator,
+        searches: std.ArrayListUnmanaged(Search) = .{},
+
+        pub fn init(allocator: Allocator, registry: *Registry) List {
+            return .{
+                .registry = registry,
+                .arena = std.heap.ArenaAllocator.init(allocator),
+            };
+        }
+
+        pub fn deinit(self: *List) void {
+            self.arena.deinit();
+        }
+
+        pub fn reset(self: *List) void {
+            self.search_id = 0;
+            self.searches = .{};
+            _ = self.arena.reset(.{ .retain_with_limit = 4096 });
+        }
+
+        pub fn create(self: *List, nodes: []const *parser.Node) !Search {
+            const id = self.search_id;
+            defer self.search_id = id +% 1;
+
+            const arena = self.arena.allocator();
+
+            const name = switch (id) {
+                0 => "0",
+                1 => "1",
+                2 => "2",
+                3 => "3",
+                4 => "4",
+                5 => "5",
+                6 => "6",
+                7 => "7",
+                8 => "8",
+                9 => "9",
+                else => try std.fmt.allocPrint(arena, "{d}", .{id}),
+            };
+
+            var registry = self.registry;
+            const node_ids = try arena.alloc(Id, nodes.len);
+            for (nodes, node_ids) |node, *node_id| {
+                node_id.* = (try registry.register(node)).id;
+            }
+
+            const search = Search{
+                .name = name,
+                .node_ids = node_ids,
+            };
+            try self.searches.append(arena, search);
+            return search;
+        }
+
+        pub fn remove(self: *List, name: []const u8) void {
+            for (self.searches.items, 0..) |search, i| {
+                if (std.mem.eql(u8, name, search.name)) {
+                    _ = self.searches.swapRemove(i);
+                    return;
+                }
+            }
+        }
+
+        pub fn get(self: *const List, name: []const u8) ?Search {
+            for (self.searches.items) |search| {
+                if (std.mem.eql(u8, name, search.name)) {
+                    return search;
+                }
+            }
+            return null;
+        }
+    };
+};
+
+const testing = @import("testing.zig");
+test "CDP Node: Registry register" {
+    var registry = Registry.init(testing.allocator);
+    defer registry.deinit();
+
+    try testing.expectEqual(0, registry.lookup_by_id.count());
+    try testing.expectEqual(0, registry.lookup_by_node.count());
+
+    var doc = try testing.Document.init("<a id=a1>link1</a><div id=d2><p>other</p></div>");
+    defer doc.deinit();
+
+    {
+        const n = (try doc.querySelector("#a1")).?;
+        const node = try registry.register(n);
+        const n1b = registry.lookup_by_id.get(0).?;
+        const n1c = registry.lookup_by_node.get(node._node).?;
+        try testing.expectEqual(node, n1b);
+        try testing.expectEqual(node, n1c);
+
+        try testing.expectEqual(0, node.id);
+        try testing.expectEqual(null, node.parent_id);
+        try testing.expectEqual(1, node.node_type);
+        try testing.expectEqual(0, node.backend_node_id);
+        try testing.expectEqual("A", node.node_name);
+        try testing.expectEqual("a", node.local_name);
+        try testing.expectEqual("", node.node_value);
+        try testing.expectEqual(1, node.child_node_count);
+        try testing.expectEqual(0, node.children.len);
+        try testing.expectEqual(null, node.document_url);
+        try testing.expectEqual(null, node.base_url);
+        try testing.expectEqual("", node.xml_version);
+        try testing.expectEqual(.NoQuirksMode, node.compatibility_mode);
+        try testing.expectEqual(false, node.is_scrollable);
+        try testing.expectEqual(n, node._node);
+    }
+
+    {
+        const n = (try doc.querySelector("p")).?;
+        const node = try registry.register(n);
+        const n1b = registry.lookup_by_id.get(1).?;
+        const n1c = registry.lookup_by_node.get(node._node).?;
+        try testing.expectEqual(node, n1b);
+        try testing.expectEqual(node, n1c);
+
+        try testing.expectEqual(1, node.id);
+        try testing.expectEqual(null, node.parent_id);
+        try testing.expectEqual(1, node.node_type);
+        try testing.expectEqual(1, node.backend_node_id);
+        try testing.expectEqual("P", node.node_name);
+        try testing.expectEqual("p", node.local_name);
+        try testing.expectEqual("", node.node_value);
+        try testing.expectEqual(1, node.child_node_count);
+        try testing.expectEqual(0, node.children.len);
+        try testing.expectEqual(null, node.document_url);
+        try testing.expectEqual(null, node.base_url);
+        try testing.expectEqual("", node.xml_version);
+        try testing.expectEqual(.NoQuirksMode, node.compatibility_mode);
+        try testing.expectEqual(false, node.is_scrollable);
+        try testing.expectEqual(n, node._node);
+    }
+}
+
+test "CDP Node: search list" {
+    var registry = Registry.init(testing.allocator);
+    defer registry.deinit();
+
+    var search_list = Search.List.init(testing.allocator, &registry);
+    defer search_list.deinit();
+
+    {
+        // empty search list, noops
+        search_list.remove("0");
+        try testing.expectEqual(null, search_list.get("0"));
+    }
+
+    {
+        // empty nodes
+        const s1 = try search_list.create(&.{});
+        try testing.expectEqual("0", s1.name);
+        try testing.expectEqual(0, s1.node_ids.len);
+
+        const s2 = search_list.get("0").?;
+        try testing.expectEqual("0", s2.name);
+        try testing.expectEqual(0, s2.node_ids.len);
+
+        search_list.remove("0");
+        try testing.expectEqual(null, search_list.get("0"));
+    }
+
+    {
+        var doc = try testing.Document.init("<a id=a1></a><a id=a2></a>");
+        defer doc.deinit();
+
+        const s1 = try search_list.create(try doc.querySelectorAll("a"));
+        try testing.expectEqual("1", s1.name);
+        try testing.expectEqualSlices(u32, &.{ 0, 1 }, s1.node_ids);
+
+        try testing.expectEqual(2, registry.lookup_by_id.count());
+        try testing.expectEqual(2, registry.lookup_by_node.count());
+
+        const s2 = try search_list.create(try doc.querySelectorAll("#a1"));
+        try testing.expectEqual("2", s2.name);
+        try testing.expectEqualSlices(u32, &.{0}, s2.node_ids);
+
+        const s3 = try search_list.create(try doc.querySelectorAll("#a2"));
+        try testing.expectEqual("3", s3.name);
+        try testing.expectEqualSlices(u32, &.{1}, s3.node_ids);
+
+        try testing.expectEqual(2, registry.lookup_by_id.count());
+        try testing.expectEqual(2, registry.lookup_by_node.count());
+    }
+}