Skip to content

Lightpanda: the headless browser designed for AI and automation

fully hook up AbortSignal for LockRequests

Muki Kiboigo5f062b63e37b
diff --git a/src/browser/tests/weblocks.html b/src/browser/tests/weblocks.html
index 56c07c1ad..8092a06a5 100644
--- a/src/browser/tests/weblocks.html
+++ b/src/browser/tests/weblocks.html
@@ -264,6 +264,101 @@
}
</script>
+<script id=abortBeforeGrantRunsRejectsAndDoesNotRunCallback type=module>
+{
+ const state = await testing.async();
+ const controller = new AbortController();
+ let ran = false;
+ const p = navigator.locks.request('abort-before-grant', { signal: controller.signal }, () => { ran = true; });
+ controller.abort();
+
+ let errName = null;
+ try {
+ await p;
+ } catch (e) {
+ errName = e.name;
+ }
+
+ const next = await navigator.locks.request('abort-before-grant', () => 'next-ok');
+
+ state.resolve(JSON.stringify({ errName, ran, next }));
+ await state.done((v) => {
+ const parsed = JSON.parse(v);
+ testing.expectEqual('AbortError', parsed.errName);
+ testing.expectEqual(false, parsed.ran);
+ testing.expectEqual('next-ok', parsed.next);
+ });
+}
+</script>
+
+<script id=abortWhilePendingRejectsAndPromotesNext type=module>
+{
+ const state = await testing.async();
+ const order = [];
+ let releaseHeld;
+ const held = navigator.locks.request('abort-pending', () => new Promise((resolve) => {
+ releaseHeld = resolve;
+ }));
+
+ await new Promise((r) => setTimeout(r, 0));
+
+ const controller = new AbortController();
+ const aborted = navigator.locks.request('abort-pending', { signal: controller.signal }, () => {
+ order.push('aborted-ran');
+ });
+ const next = navigator.locks.request('abort-pending', () => {
+ order.push('next-ran');
+ return 'next-done';
+ });
+
+ controller.abort('bye');
+
+ let abortedReason = null;
+ try {
+ await aborted;
+ } catch (e) {
+ abortedReason = e;
+ }
+
+ releaseHeld();
+ await held;
+ const nextResult = await next;
+
+ state.resolve(JSON.stringify({ order, abortedReason, nextResult }));
+ await state.done((v) => {
+ const parsed = JSON.parse(v);
+ testing.expectEqual('bye', parsed.abortedReason);
+ testing.expectEqual(false, parsed.order.includes('aborted-ran'));
+ testing.expectEqual('next-done', parsed.nextResult);
+ });
+}
+</script>
+
+<script id=abortAfterCallbackAlreadyRanIsNoop type=module>
+{
+ const state = await testing.async();
+ let acquiredResolve;
+ const acquired = new Promise((r) => { acquiredResolve = r; });
+ let releaseFn;
+
+ const controller = new AbortController();
+ const p = navigator.locks.request('abort-after-grant', { signal: controller.signal }, () => {
+ acquiredResolve();
+ return new Promise((resolve) => { releaseFn = resolve; });
+ });
+
+ await acquired;
+ controller.abort();
+ releaseFn('resolved-ok');
+
+ const result = await p;
+ state.resolve(result);
+ await state.done((v) => {
+ testing.expectEqual('resolved-ok', v);
+ });
+}
+</script>
+
<script id=nameStartingWithDashIsRejected type=module>
{
const state = await testing.async();
diff --git a/src/browser/webapi/AbortSignal.zig b/src/browser/webapi/AbortSignal.zig
index 3281bf5ac..d5d71b143 100644
--- a/src/browser/webapi/AbortSignal.zig
+++ b/src/browser/webapi/AbortSignal.zig
@@ -28,6 +28,7 @@ const Scheduler = @import("Scheduler.zig");
const EventTarget = @import("EventTarget.zig");
const DOMException = @import("DOMException.zig");
const ModelContextTool = @import("ModelContext.zig").Tool;
+const LockRequest = @import("LockManager.zig").LockRequest;
const log = lp.log;
const Execution = js.Execution;
@@ -43,6 +44,7 @@ const Dependend = union(enum) {
// signals too, unlike this union's markAborted).
scheduler_task: *Scheduler.Task,
fetch: *Fetch, // The fetch removes itself when it completes.
+ lock_request: *LockRequest,
// Returns false if the dependent was already aborted, in which case no
// abort event must be dispatched for it.
@@ -57,7 +59,7 @@ const Dependend = union(enum) {
try dep.markAborted(exec);
return true;
},
- .scheduler_task, .fetch => return false,
+ .scheduler_task, .fetch, .lock_request => return false,
}
}
@@ -65,6 +67,7 @@ const Dependend = union(enum) {
switch (self) {
.signal => |dep| try dep.dispatchAbortEvent(exec),
.model_context_tool, .scheduler_task, .fetch => {},
+ .model_context_tool, .scheduler_task, .fetch, .lock_request => {},
}
}
};
@@ -157,6 +160,7 @@ fn markAborted(self: *AbortSignal, reason_: ?Reason, exec: *const Execution) !vo
switch (dep) {
.scheduler_task => |task| task.onAbort(self._reason, exec),
.fetch => |fetch| fetch.abort(self._reason),
+ .lock_request => |lr| lr.onAbort(self._reason, exec),
else => {},
}
}
diff --git a/src/browser/webapi/LockManager.zig b/src/browser/webapi/LockManager.zig
index 7f9de09ad..e89c31f7c 100644
--- a/src/browser/webapi/LockManager.zig
+++ b/src/browser/webapi/LockManager.zig
@@ -42,7 +42,7 @@ pub const Options = struct {
const LockState = enum { pending, held };
// A pending or in-flight lock request
-const LockRequest = struct {
+pub const LockRequest = struct {
manager: *LockManager,
name: lp.String,
options: Options,
@@ -190,6 +190,24 @@ const LockRequest = struct {
self.finished = true;
self.deinit();
}
+
+ pub fn onAbort(self: *LockRequest, reason: AbortSignal.Reason, exec: *const Execution) void {
+ if (self.finished or self.granted) return;
+ self.finished = true;
+
+ var ls: js.Local.Scope = undefined;
+ exec.js.localScope(&ls);
+ defer ls.deinit();
+
+ const resolver = self.resolver.local(&ls.local);
+ const value = AbortSignal.reasonJsValue(reason, &ls.local) catch {
+ resolver.rejectError("LockManager.signal.aborted", .{ .dom_exception = .{ .err = error.AbortError } });
+ self.manager.releaseLock(self);
+ return;
+ };
+ resolver.reject("LockManager.signal.aborted", value);
+ self.manager.releaseLock(self);
+ }
};
fn heldConflicts(self: *const LockManager, name: lp.String, mode: Lock.LockMode) bool {
@@ -322,11 +340,17 @@ pub fn request(
if (must_queue_request) {
try self._locks.append(exec.arena, lock_request);
+ if (options.signal) |signal| {
+ try signal._dependents.append(exec.arena, .{ .lock_request = lock_request });
+ }
return promise;
}
lock_request.state = .held;
try self._locks.append(exec.arena, lock_request);
+ if (options.signal) |signal| {
+ try signal._dependents.append(exec.arena, .{ .lock_request = lock_request });
+ }
lock_request.scheduleFireCallback();
return promise;
}