Introduce more general notification capabilities

Replaces the existing, very specialized Notification with something more
general.

Currently, the existing page_navigate and page_navigated have been migrated.

Telemetry's page navigation event now also hooks into these events to generate
the telemetry record.

Author: karlseguin

src/app.zig

@@ -5,6 +5,7 @@ const js = @import("runtime/js.zig");
 const Loop = @import("runtime/loop.zig").Loop;
 const HttpClient = @import("http/client.zig").Client;
 const Telemetry = @import("telemetry/telemetry.zig").Telemetry;
+const Notification = @import("notification.zig").Notification;
 
 const log = std.log.scoped(.app);
 
@@ -17,6 +18,7 @@ pub const App = struct {
     telemetry: Telemetry,
     http_client: HttpClient,
     app_dir_path: ?[]const u8,
+    notification: *Notification,
 
     pub const RunMode = enum {
         help,
@@ -41,19 +43,24 @@ pub const App = struct {
         loop.* = try Loop.init(allocator);
         errdefer loop.deinit();
 
+        const notification = try Notification.init(allocator, null);
+        errdefer notification.deinit();
+
         const app_dir_path = getAndMakeAppDir(allocator);
 
         app.* = .{
             .loop = loop,
             .allocator = allocator,
             .telemetry = undefined,
             .app_dir_path = app_dir_path,
+            .notification = notification,
             .http_client = try HttpClient.init(allocator, 5, .{
                 .tls_verify_host = config.tls_verify_host,
             }),
             .config = config,
         };
         app.telemetry = Telemetry.init(app, config.run_mode);
+        try app.telemetry.register(app.notification);
 
         return app;
     }
@@ -67,6 +74,7 @@ pub const App = struct {
         self.loop.deinit();
         allocator.destroy(self.loop);
         self.http_client.deinit();
+        self.notification.deinit();
         allocator.destroy(self);
     }
 };

src/browser/browser.zig

@@ -57,6 +57,7 @@ pub const Browser = struct {
     allocator: Allocator,
     http_client: *http.Client,
     session_pool: SessionPool,
+    notification: *Notification,
     page_arena: std.heap.ArenaAllocator,
     pub const EnvType = Env;
 
@@ -70,11 +71,15 @@ pub const Browser = struct {
         });
         errdefer env.deinit();
 
+        const notification = try Notification.init(allocator, app.notification);
+        errdefer notification.deinit();
+
         return .{
             .app = app,
             .env = env,
             .session = null,
             .allocator = allocator,
+            .notification = notification,
             .http_client = &app.http_client,
             .session_pool = SessionPool.init(allocator),
             .page_arena = std.heap.ArenaAllocator.init(allocator),
@@ -86,6 +91,7 @@ pub const Browser = struct {
         self.env.deinit();
         self.session_pool.deinit();
         self.page_arena.deinit();
+        self.notification.deinit();
     }
 
     pub fn newSession(self: *Browser, ctx: anytype) !*Session {
@@ -143,32 +149,14 @@ pub const Session = struct {
     page: ?Page = null,
     http_client: *http.Client,
 
-    // recipient of notification, passed as the first parameter to notify
-    notify_ctx: *anyopaque,
-    notify_func: *const fn (ctx: *anyopaque, notification: *const Notification) anyerror!void,
-
     fn init(self: *Session, browser: *Browser, ctx: anytype) !void {
-        const ContextT = @TypeOf(ctx);
-        const ContextStruct = switch (@typeInfo(ContextT)) {
-            .@"struct" => ContextT,
-            .pointer => |ptr| ptr.child,
-            .void => NoopContext,
-            else => @compileError("invalid context type"),
-        };
-
-        // ctx can be void, to be able to store it in our *anyopaque field, we
-        // need to play a little game.
-        const any_ctx: *anyopaque = if (@TypeOf(ctx) == void) @constCast(@ptrCast(&{})) else ctx;
-
         const app = browser.app;
         const allocator = app.allocator;
         self.* = .{
             .app = app,
             .aux_data = null,
             .browser = browser,
-            .notify_ctx = any_ctx,
             .inspector = undefined,
-            .notify_func = ContextStruct.notify,
             .http_client = browser.http_client,
             .executor = undefined,
             .storage_shed = storage.Shed.init(allocator),
@@ -313,12 +301,6 @@ pub const Session = struct {
         log.debug("inspector context created", .{});
         self.inspector.contextCreated(self.executor, "", (page.origin() catch "://") orelse "://", self.aux_data, true);
     }
-
-    fn notify(self: *const Session, notification: *const Notification) void {
-        self.notify_func(self.notify_ctx, notification) catch |err| {
-            log.err("notify {}: {}", .{ std.meta.activeTag(notification.*), err });
-        };
-    }
 };
 
 // Page navigates to an url.
@@ -389,8 +371,6 @@ pub const Page = struct {
     }
 
     // spec reference: https://html.spec.whatwg.org/#document-lifecycle
-    // - aux_data: extra data forwarded to the Inspector
-    // see Inspector.contextCreated
     pub fn navigate(self: *Page, request_url: URL, opts: NavigateOpts) !void {
         const arena = self.arena;
         const session = self.session;
@@ -408,20 +388,15 @@ pub const Page = struct {
         self.url = request_url;
         var url = &self.url.?;
 
-        session.app.telemetry.record(.{ .navigate = .{
-            .proxy = false,
-            .tls = std.ascii.eqlIgnoreCase(url.scheme(), "https"),
-        } });
-
         // load the data
         var request = try self.newHTTPRequest(.GET, url, .{ .navigation = true });
         defer request.deinit();
 
-        session.notify(&.{ .page_navigate = .{
+        session.browser.notification.dispatch(.page_navigate, &.{
             .url = url,
             .reason = opts.reason,
             .timestamp = timestamp(),
-        } });
+        });
 
         var response = try request.sendSync(.{});
 
@@ -458,10 +433,10 @@ pub const Page = struct {
             self.raw_data = arr.items;
         }
 
-        session.notify(&.{ .page_navigated = .{
+        session.browser.notification.dispatch(.page_navigated, &.{
             .url = url,
             .timestamp = timestamp(),
-        } });
+        });
     }
 
     // https://html.spec.whatwg.org/#read-html

src/cdp/cdp.zig

@@ -336,6 +336,10 @@ pub fn BrowserContext(comptime CDP_T: type) type {
                 .isolated_world = null,
             };
             self.node_search_list = Node.Search.List.init(allocator, &self.node_registry);
+            errdefer self.deinit();
+
+            try cdp.browser.notification.register(.page_navigate, self, onPageNavigate);
+            try cdp.browser.notification.register(.page_navigated, self, onPageNavigated);
         }
 
         pub fn deinit(self: *Self) void {
@@ -346,6 +350,7 @@ pub fn BrowserContext(comptime CDP_T: type) type {
             }
             self.node_registry.deinit();
             self.node_search_list.deinit();
+            self.cdp.browser.notification.unregisterAll(self);
         }
 
         pub fn reset(self: *Self) void {
@@ -387,13 +392,14 @@ pub fn BrowserContext(comptime CDP_T: type) type {
             return if (page.url) |*url| url.raw else null;
         }
 
-        pub fn notify(ctx: *anyopaque, notification: *const Notification) !void {
+        pub fn onPageNavigate(ctx: *anyopaque, data: *const Notification.PageNavigate) !void {
             const self: *Self = @alignCast(@ptrCast(ctx));
+            return @import("domains/page.zig").pageNavigate(self, data);
+        }
 
-            switch (notification.*) {
-                .page_navigate => |*pn| return @import("domains/page.zig").pageNavigate(self, pn),
-                .page_navigated => |*pn| return @import("domains/page.zig").pageNavigated(self, pn),
-            }
+        pub fn onPageNavigated(ctx: *anyopaque, data: *const Notification.PageNavigated) !void {
+            const self: *Self = @alignCast(@ptrCast(ctx));
+            return @import("domains/page.zig").pageNavigated(self, data);
         }
 
         pub fn onInspectorResponse(ctx: *anyopaque, _: u32, msg: []const u8) void {

src/cdp/testing.zig

@@ -25,6 +25,8 @@ const Testing = @This();
 const main = @import("cdp.zig");
 const URL = @import("../url.zig").URL;
 const App = @import("../app.zig").App;
+const Notification = @import("../notification.zig").Notification;
+
 const parser = @import("../browser/netsurf.zig");
 
 const base = @import("../testing.zig");
@@ -37,20 +39,26 @@ pub const expectEqualSlices = base.expectEqualSlices;
 pub const Document = @import("../testing.zig").Document;
 
 const Browser = struct {
+    env: Env,
     session: ?*Session = null,
     arena: std.heap.ArenaAllocator,
-    env: Env,
+    notification: *Notification,
     pub const EnvType = Env;
 
     pub fn init(app: *App) !Browser {
+        const notification = try Notification.init(app.allocator, null);
+        errdefer notification.deinit();
+
         return .{
+            .env = .{},
+            .notification = notification,
             .arena = std.heap.ArenaAllocator.init(app.allocator),
-            .env = Env{},
         };
     }
 
     pub fn deinit(self: *Browser) void {
         self.arena.deinit();
+        self.notification.deinit();
     }
 
     pub fn newSession(self: *Browser, ctx: anytype) !*Session {
@@ -273,7 +281,7 @@ const TestContext = struct {
             self.client = Client.init(self.arena.allocator());
             // Don't use the arena here. We want to detect leaks in CDP.
             // The arena is only for test-specific stuff
-            self.cdp_ = try TestCDP.init(self.app, &self.client.?);
+            self.cdp_ = TestCDP.init(self.app, &self.client.?) catch unreachable;
         }
         return &self.cdp_.?;
     }