Skip to content

Lightpanda: the headless browser designed for AI and automation

syncRequest -> submitSync on Transfer

Muki Kiboigo234d47d0e2ab
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index cd9de0719..f01195b84 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -2332,7 +2332,7 @@ pub fn loadExternalStylesheet(self: *Frame, link: *Element.Html.Link, href: []co
sm.is_evaluating = true;
defer sm.endEvaluationWindow(was_evaluating);
- var response = http_client.syncRequest(transfer) catch |err| {
+ var response = transfer.submitSync() catch |err| {
log.warn(.http, "external stylesheet fetch", .{ .err = err, .url = resolved });
return self.fireElementEvent(element, comptime .wrap("error"));
};
diff --git a/src/browser/ScriptManager.zig b/src/browser/ScriptManager.zig
index 7d1dcce61..0d98777e0 100644
--- a/src/browser/ScriptManager.zig
+++ b/src/browser/ScriptManager.zig
@@ -362,7 +362,8 @@ pub fn addFromElement(self: *ScriptManager, comptime from_parser: bool, script_e
errdefer transfer.deinit();
try frame.headersForRequest(transfer);
}
- const response = try self.base.client.syncRequest(transfer);
+
+ const response = try transfer.submitSync();
// Take the body's arena rather than releasing it: `source`
// has to outlive this call, up to script.deinit().
diff --git a/src/browser/webapi/WorkerGlobalScope.zig b/src/browser/webapi/WorkerGlobalScope.zig
index e65a68dc9..e83709d3c 100644
--- a/src/browser/webapi/WorkerGlobalScope.zig
+++ b/src/browser/webapi/WorkerGlobalScope.zig
@@ -436,7 +436,7 @@ fn importScript(self: *WorkerGlobalScope, arena: Allocator, url: [:0]const u8) !
try self.headersForRequest(transfer);
}
- var response = http_client.syncRequest(transfer) catch |err| {
+ var response = transfer.submitSync() catch |err| {
log.warn(.http, "importScript", .{ .url = resolved_url, .err = err });
return error.NetworkError;
};
diff --git a/src/cdp/CDP.zig b/src/cdp/CDP.zig
index f82bbc19a..2e955cb78 100644
--- a/src/cdp/CDP.zig
+++ b/src/cdp/CDP.zig
@@ -1560,5 +1560,5 @@ test "cdp: syncRequest short-circuits after disconnect" {
.notification = undefined,
.shutdown_callback = @import("../network/HttpClient.zig").noopShutdown,
}, null);
- try testing.expectError(error.ClientDisconnected, client.syncRequest(transfer));
+ try testing.expectError(error.ClientDisconnected, transfer.submitSync());
}
diff --git a/src/network/HttpClient.zig b/src/network/HttpClient.zig
index f1a50d102..8f1ce5c88 100644
--- a/src/network/HttpClient.zig
+++ b/src/network/HttpClient.zig
@@ -1226,69 +1226,6 @@ const SyncContext = struct {
}
};
-// Synchronous submit for a transfer created with newRequest. Like `submit`,
-// `syncRequest` consuems the transfer unconditionally.
-// Caller must deinit SyncResponse or otherwise take ownership of its optional arena
-pub fn syncRequest(self: *Client, transfer: *Transfer) !SyncResponse {
- if (self.inbox.terminated) {
- transfer.deinit();
- return error.ClientDisconnected;
- }
- // A parser can start another blocking script/style fetch while unwinding
- // a previous interrupted fetch. The first tickSync below would fail
- // anyway; bail before submitting and notifying CDP.
- if (self.hasPendingTeardown()) {
- transfer.deinit();
- return error.SyncWaitInterrupted;
- }
-
- var sync_ctx = SyncContext{ .client = self, .body = .empty };
- errdefer if (sync_ctx.arena) |arena| arena.release();
-
- const req = &transfer.req;
- req.sync = true;
- req.ctx = &sync_ctx;
- req.header_callback = SyncContext.headerCallback;
- req.data_callback = SyncContext.dataCallback;
- req.done_callback = SyncContext.doneCallback;
- req.error_callback = SyncContext.errorCallback;
- req.shutdown_callback = SyncContext.shutdownCallback;
-
- const frame_id = req.frame_id;
- self.blocking_requests.putNoClobber(self.allocator, frame_id, transfer.id) catch |err| {
- transfer.deinit();
- return err;
- };
- defer self.releaseBlocking(frame_id);
-
- try transfer.submit();
-
- while (sync_ctx.completion == .in_progress) {
- self.tickSync(200) catch |err| {
- if (sync_ctx.completion == .in_progress) {
- // tick failed for a reason unrelated to our transfer: OOM,
- // client disconnect, or a queued teardown command (which
- // sync_wait can't dispatch mid-parse — it would free the
- // Page/Frame this stack holds). transfer.req.ctx points at
- // &sync_ctx on this stack — abort to sever that reference
- // before we return
- transfer.abort(err);
- }
- return err;
- };
- }
-
- switch (sync_ctx.completion) {
- .in_progress => @panic("Impossible to be in progress here."),
- .done, .shutdown => return .{
- .status = sync_ctx.status,
- .body = sync_ctx.body,
- .arena = sync_ctx.arena,
- },
- .err => |e| return e,
- }
-}
-
fn processTransfer(self: *Client, transfer: *Transfer) !void {
if (self.network.getConnection()) |conn| {
return self.makeRequest(conn, transfer);
@@ -2283,6 +2220,69 @@ pub const Transfer = struct {
};
}
+ pub fn submitSync(self: *Transfer) !SyncResponse {
+ const client = self.client;
+
+ if (client.inbox.terminated) {
+ self.deinit();
+ return error.ClientDisconnected;
+ }
+
+ // A parser can start another blocking script/style fetch while unwinding
+ // a previous interrupted fetch. The first tickSync below would fail
+ // anyway; bail before submitting and notifying CDP.
+ if (client.hasPendingTeardown()) {
+ self.deinit();
+ return error.SyncWaitInterrupted;
+ }
+
+ var sync_ctx = SyncContext{ .client = client, .body = .empty };
+ errdefer if (sync_ctx.arena) |arena| arena.release();
+
+ const req = &self.req;
+ req.sync = true;
+ req.ctx = &sync_ctx;
+ req.header_callback = SyncContext.headerCallback;
+ req.data_callback = SyncContext.dataCallback;
+ req.done_callback = SyncContext.doneCallback;
+ req.error_callback = SyncContext.errorCallback;
+ req.shutdown_callback = SyncContext.shutdownCallback;
+
+ const frame_id = req.frame_id;
+ client.blocking_requests.putNoClobber(client.allocator, frame_id, self.id) catch |err| {
+ self.deinit();
+ return err;
+ };
+ defer client.releaseBlocking(frame_id);
+
+ try self.submit();
+
+ while (sync_ctx.completion == .in_progress) {
+ client.tickSync(200) catch |err| {
+ if (sync_ctx.completion == .in_progress) {
+ // tick failed for a reason unrelated to our transfer: OOM,
+ // client disconnect, or a queued teardown command (which
+ // sync_wait can't dispatch mid-parse — it would free the
+ // Page/Frame this stack holds). transfer.req.ctx points at
+ // &sync_ctx on this stack — abort to sever that reference
+ // before we return
+ self.abort(err);
+ }
+ return err;
+ };
+ }
+
+ switch (sync_ctx.completion) {
+ .in_progress => @panic("Impossible to be in progress here."),
+ .done, .shutdown => return .{
+ .status = sync_ctx.status,
+ .body = sync_ctx.body,
+ .arena = sync_ctx.arena,
+ },
+ .err => |e| return e,
+ }
+ }
+
pub fn deinit(self: *Transfer) void {
if (self._retired) {
// transfer.deinit should be called once. But _retired and the graveyard