defer callback handling, not http req

Author: mookums

src/browser/Frame.zig

@@ -983,7 +983,7 @@ fn frameHeaderDoneCallback(response: HttpClient.Response) !bool {
         try self._session.commitPendingPage();
         switch (response.inner) {
             .transfer => |t| t.req.params.protect_from_abort = false,
-            .fulfilled, .cached => {},
+            .fulfilled, .cached, .stable => {},
         }
     }
 

src/browser/HttpClient.zig

@@ -993,12 +993,28 @@ pub const FulfilledResponse = struct {
     }
 };
 
+pub const StableResponse = struct {
+    ctx: *anyopaque,
+    status: u16,
+    url: [:0]const u8,
+    headers: []const http.Header,
+    body: ?[]const u8,
+
+    pub fn contentType(self: *const StableResponse) ?[]const u8 {
+        for (self.headers) |hdr| {
+            if (std.ascii.eqlIgnoreCase(hdr.name, "content-type")) return hdr.value;
+        }
+        return null;
+    }
+};
+
 pub const Response = struct {
     ctx: *anyopaque,
     inner: union(enum) {
         transfer: *Transfer,
         cached: *const CachedResponse,
         fulfilled: *const FulfilledResponse,
+        stable: *const StableResponse,
     },
 
     pub fn fromTransfer(transfer: *Transfer) Response {
@@ -1013,11 +1029,16 @@ pub const Response = struct {
         return .{ .ctx = ctx, .inner = .{ .fulfilled = fulfilled } };
     }
 
+    pub fn fromStable(stable: *const StableResponse) Response {
+        return .{ .ctx = stable.ctx, .inner = .{ .stable = stable } };
+    }
+
     pub fn status(self: Response) ?u16 {
         return switch (self.inner) {
             .transfer => |t| if (t.response_header) |rh| rh.status else null,
             .cached => |c| c.metadata.status,
             .fulfilled => |f| f.status,
+            .stable => |s| s.status,
         };
     }
 
@@ -1026,6 +1047,7 @@ pub const Response = struct {
             .transfer => |t| if (t.response_header) |*rh| rh.contentType() else null,
             .cached => |c| c.metadata.content_type,
             .fulfilled => |f| f.contentType(),
+            .stable => |s| s.contentType(),
         };
     }
 
@@ -1037,13 +1059,14 @@ pub const Response = struct {
                 .file => |f| @intCast(f.len),
             },
             .fulfilled => |f| if (f.body) |b| @intCast(b.len) else null,
+            .stable => |s| if (s.body) |b| @intCast(b.len) else null,
         };
     }
 
     pub fn redirectCount(self: Response) ?u32 {
         return switch (self.inner) {
             .transfer => |t| if (t.response_header) |rh| rh.redirect_count else null,
-            .cached, .fulfilled => 0,
+            .cached, .fulfilled, .stable => 0,
         };
     }
 
@@ -1052,6 +1075,7 @@ pub const Response = struct {
             .transfer => |t| t.url,
             .cached => |c| c.metadata.url,
             .fulfilled => |f| f.url,
+            .stable => |s| s.url,
         };
     }
 
@@ -1060,13 +1084,14 @@ pub const Response = struct {
             .transfer => |t| t.responseHeaderIterator(),
             .cached => |c| HeaderIterator{ .list = .{ .list = c.metadata.headers } },
             .fulfilled => |f| HeaderIterator{ .list = .{ .list = f.headers } },
+            .stable => |s| HeaderIterator{ .list = .{ .list = s.headers } },
         };
     }
 
     pub fn abort(self: Response, err: anyerror) void {
         switch (self.inner) {
             .transfer => |t| t.abort(err),
-            .cached, .fulfilled => {},
+            .cached, .fulfilled, .stable => {},
         }
     }
 
@@ -1075,6 +1100,28 @@ pub const Response = struct {
             .transfer => |t| try t.format(writer),
             .cached => |c| try c.format(writer),
             .fulfilled => |f| try writer.print("fulfilled {s}", .{f.url}),
+            .stable => |s| writer.print("stable {s}", .{s.url}),
+        };
+    }
+
+    pub fn toStable(self: Response, arena: std.mem.Allocator) !StableResponse {
+        const new_url = try arena.dupeZ(u8, self.url());
+
+        var headers: std.ArrayListUnmanaged(http.Header) = .{};
+        var it = self.headerIterator();
+        while (it.next()) |hdr| {
+            try headers.append(arena, .{
+                .name = try arena.dupe(u8, hdr.name),
+                .value = try arena.dupe(u8, hdr.value),
+            });
+        }
+
+        return .{
+            .ctx = self.ctx,
+            .status = self.status() orelse 0,
+            .url = new_url,
+            .headers = headers.items,
+            .body = null,
         };
     }
 };

src/network/layer/DeferringLayer.zig

@@ -24,15 +24,14 @@ const Client = @import("../../browser/HttpClient.zig").Client;
 const Request = @import("../../browser/HttpClient.zig").Request;
 const Response = @import("../../browser/HttpClient.zig").Response;
 const Layer = @import("../../browser/HttpClient.zig").Layer;
+const StableResponse = @import("../../browser/HttpClient.zig").StableResponse;
 const Forward = @import("Forward.zig");
 
 const DeferringLayer = @This();
 
 allocator: std.mem.Allocator,
 next: Layer = undefined,
 
-// Requests whose callbacks should be deferred until flush() is called.
-// Each node is a DeferredRequest allocated in the request's arena.
 deferred: std.DoublyLinkedList = .{},
 
 pub fn layer(self: *DeferringLayer) Layer {
@@ -49,10 +48,13 @@ pub fn deinit(self: *DeferringLayer) void {
 fn request(ptr: *anyopaque, client: *Client, in_req: Request) anyerror!void {
     const self: *DeferringLayer = @ptrCast(@alignCast(ptr));
 
-    const deferred_req = try self.allocator.create(DeferredContext);
-    errdefer self.allocator.destroy(deferred_req);
+    const arena = try client.network.app.arena_pool.acquire(.small, "DeferringContext");
+    errdefer client.network.app.arena_pool.release(arena);
+
+    const deferred_req = try arena.create(DeferredContext);
 
     deferred_req.* = .{
+        .arena = arena,
         .layer = self,
         .client = client,
         .forward = Forward.fromRequest(in_req),
@@ -92,8 +94,6 @@ pub fn flushUnblocked(
     }
 }
 
-// Flush all deferred requests on the frame, firing their done/error callbacks.
-// This happens to requests ONLY on the given frame.
 pub fn flushFrame(self: *DeferringLayer, frame_id: u32) void {
     var node = self.deferred.first;
     while (node) |n| {
@@ -119,7 +119,6 @@ pub fn drainAll(self: *DeferringLayer) void {
 
 pub fn drainFrame(self: *DeferringLayer, frame_id: u32, opts: Client.AbortOpts) void {
     var node = self.deferred.first;
-
     while (node) |n| {
         node = n.next;
         const deferred: *DeferredContext = @fieldParentPtr("node", n);
@@ -134,92 +133,172 @@ pub fn drainFrame(self: *DeferringLayer, frame_id: u32, opts: Client.AbortOpts)
 }
 
 const DeferredContext = struct {
+    arena: std.mem.Allocator,
     layer: *DeferringLayer,
     client: *Client,
     forward: Forward,
     request: Request,
     node: std.DoublyLinkedList.Node,
 
-    outcome: union(enum) {
-        none,
+    buffered: std.ArrayListUnmanaged(BufferedEvent) = .{},
+    deferring: bool = false,
+    stable_resp: ?StableResponse = null,
+
+    const BufferedEvent = union(enum) {
+        start,
+        header,
+        data: []const u8,
         done,
         err: anyerror,
         shutdown,
-    } = .none,
+    };
 
     fn deinit(self: *DeferredContext) void {
-        self.layer.allocator.destroy(self);
+        self.client.network.app.arena_pool.release(self.arena);
     }
 
     fn shouldDefer(self: *DeferredContext) bool {
         const blocking_id = self.client.blocking_requests.get(self.request.params.frame_id) orelse return false;
         return self.request.params.request_id != blocking_id;
     }
 
+    fn beginDefer(self: *DeferredContext) !void {
+        if (self.deferring) return;
+        self.deferring = true;
+        self.layer.deferred.append(&self.node);
+    }
+
     fn startCallback(response: Response) anyerror!void {
         const self: *DeferredContext = @ptrCast(@alignCast(response.ctx));
-        return self.forward.forwardStart(response);
+
+        if (!self.deferring and !self.shouldDefer()) {
+            return self.forward.forwardStart(response);
+        }
+
+        log.debug(.http, "deferring start callback", .{ .url = self.request.params.url });
+        self.stable_resp = try response.toStable(self.arena);
+        try self.beginDefer();
+        try self.buffered.append(self.arena, .start);
     }
 
     fn headerCallback(response: Response) anyerror!bool {
         const self: *DeferredContext = @ptrCast(@alignCast(response.ctx));
-        return self.forward.forwardHeader(response);
+
+        if (!self.deferring and !self.shouldDefer()) {
+            return self.forward.forwardHeader(response);
+        }
+
+        log.debug(.http, "deferring header callback", .{ .url = self.request.params.url });
+        self.stable_resp = try response.toStable(self.arena);
+        try self.beginDefer();
+        try self.buffered.append(self.arena, .header);
+        return true;
     }
 
     fn dataCallback(response: Response, chunk: []const u8) anyerror!void {
         const self: *DeferredContext = @ptrCast(@alignCast(response.ctx));
-        return self.forward.forwardData(response, chunk);
+
+        if (!self.deferring and !self.shouldDefer()) {
+            return self.forward.forwardData(response, chunk);
+        }
+
+        log.debug(.http, "deferring data callback", .{ .url = self.request.params.url });
+        try self.beginDefer();
+        try self.buffered.append(self.arena, .{ .data = try self.arena.dupe(u8, chunk) });
     }
 
     fn doneCallback(ctx: *anyopaque) anyerror!void {
         const self: *DeferredContext = @ptrCast(@alignCast(ctx));
-        if (self.shouldDefer()) {
-            log.debug(.http, "deferring done callback", .{ .url = self.request.params.url });
-            self.outcome = .done;
-            self.layer.deferred.append(&self.node);
-            return;
+
+        if (!self.deferring and !self.shouldDefer()) {
+            defer self.deinit();
+            return self.forward.forwardDone();
         }
 
-        defer self.deinit();
-        return self.forward.forwardDone();
+        log.debug(.http, "deferring done callback", .{ .url = self.request.params.url });
+        try self.beginDefer();
+        try self.buffered.append(self.arena, .done);
     }
 
     fn errorCallback(ctx: *anyopaque, err: anyerror) void {
         const self: *DeferredContext = @ptrCast(@alignCast(ctx));
-        if (self.shouldDefer()) {
-            log.debug(.http, "deferring error callback", .{ .url = self.request.params.url, .err = err });
-            self.outcome = .{ .err = err };
-            self.layer.deferred.append(&self.node);
+
+        if (!self.deferring and !self.shouldDefer()) {
+            defer self.deinit();
+            self.forward.forwardErr(err);
             return;
         }
 
-        defer self.deinit();
-        self.forward.forwardErr(err);
+        log.debug(.http, "deferring error callback", .{ .url = self.request.params.url, .err = err });
+        self.beginDefer() catch {};
+        self.buffered.append(self.arena, .{ .err = err }) catch {};
     }
 
     fn shutdownCallback(ctx: *anyopaque) void {
         const self: *DeferredContext = @ptrCast(@alignCast(ctx));
-        if (self.shouldDefer()) {
-            self.outcome = .shutdown;
-            self.layer.deferred.append(&self.node);
+
+        if (!self.deferring and !self.shouldDefer()) {
+            defer self.deinit();
+            self.forward.forwardShutdown();
             return;
         }
 
-        defer self.deinit();
-        self.forward.forwardShutdown();
+        log.debug(.http, "deferring shutdown callback", .{ .url = self.request.params.url });
+        self.beginDefer() catch {};
+        self.buffered.append(self.arena, .shutdown) catch {};
     }
 
+    // Replay all buffered events in order, then clean up.
     fn fire(self: *DeferredContext) void {
         defer self.deinit();
 
-        switch (self.outcome) {
-            .none => unreachable,
-            .done => self.forward.forwardDone() catch |err| {
-                log.err(.http, "deferred done callback", .{ .err = err, .url = self.request.params.url });
-                self.forward.forwardErr(err);
-            },
-            .err => |err| self.forward.forwardErr(err),
-            .shutdown => self.forward.forwardShutdown(),
+        const stable_response = self.stable_resp.?;
+        const response = Response.fromStable(&stable_response);
+
+        for (self.buffered.items) |event| {
+            switch (event) {
+                .start => {
+                    self.forward.forwardStart(response) catch |err| {
+                        log.err(.http, "deferred start callback", .{ .err = err, .url = self.request.params.url });
+                        self.forward.forwardErr(err);
+                        return;
+                    };
+                },
+                .header => {
+                    const proceed = self.forward.forwardHeader(response) catch |err| {
+                        log.err(.http, "deferred header callback", .{ .err = err, .url = self.request.params.url });
+                        self.forward.forwardErr(err);
+                        return;
+                    };
+
+                    if (!proceed) {
+                        self.forward.forwardErr(error.Abort);
+                    }
+                },
+                .data => |chunk| {
+                    self.forward.forwardData(response, chunk) catch |err| {
+                        log.err(.http, "deferred data callback", .{ .err = err, .url = self.request.params.url });
+                        self.forward.forwardErr(err);
+                        return;
+                    };
+                },
+                .done => {
+                    self.forward.forwardDone() catch |err| {
+                        log.err(.http, "deferred done callback", .{ .err = err, .url = self.request.params.url });
+                        self.forward.forwardErr(err);
+                    };
+
+                    return;
+                },
+                .err => |err| {
+                    self.forward.forwardErr(err);
+                    return;
+                },
+                .shutdown => {
+                    self.forward.forwardShutdown();
+                    return;
+                },
+            }
         }
     }
 };