Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: Make MessagePort transferable

Karl Seguin253bf79f3766
diff --git a/src/browser/js/Value.zig b/src/browser/js/Value.zig
index a2ab7fa6f..015d06d8a 100644
--- a/src/browser/js/Value.zig
+++ b/src/browser/js/Value.zig
@@ -410,8 +410,8 @@ pub fn jsonStringify(self: Value, jws: anytype) !void {
}
// Clones host objects listed in cloneable_types; throws a DataCloneError for
-// any other. Does not support transferables which require additional delegate
-// callbacks.
+// any other. Transferring MessagePorts goes through serializeTransfer /
+// deserializeTransfer (see MessagePort.cloneMessage).
pub fn structuredClone(self: Value) !Value {
return self.structuredCloneTo(self.local);
}
@@ -442,9 +442,17 @@ pub const Serialized = struct {
// Serialize `self` into a V8-owned buffer. The caller must call deinit on the
// result. Raises a JS exception (DataCloneError) for unserializable values.
pub fn serialize(self: Value) !Serialized {
+ return self.serializeTransfer(&.{});
+}
+
+// Like serialize, but each MessagePort in `transfer` is written as its index
+// in that list, for deserializeTransfer to swap in the moved port. A port not
+// in `transfer` is still a DataCloneError.
+pub fn serializeTransfer(self: Value, transfer: []const *MessagePort) !Serialized {
var delegate_ctx = CloneDelegate.SerializeContext{
.local = self.local,
.serializer = undefined,
+ .transfer = transfer,
};
const serializer = v8.v8__ValueSerializer__New(self.local.isolate.handle, &.{
.data = &delegate_ctx,
@@ -472,9 +480,16 @@ pub fn serialize(self: Value) !Serialized {
// Deserialize a structured-serialized buffer (from `serialize`) into a value in
// `local`'s context. A malformed buffer surfaces as error.JsException.
pub fn deserialize(local: *const js.Local, bytes: []const u8) !Value {
+ return deserializeTransfer(local, bytes, &.{});
+}
+
+// `ports` are the transferred ports, already moved into `local`'s context, in
+// the order of the `transfer` list given to serializeTransfer.
+pub fn deserializeTransfer(local: *const js.Local, bytes: []const u8, ports: []const *MessagePort) !Value {
var delegate_ctx = CloneDelegate.DeserializeContext{
.local = local,
.deserializer = undefined,
+ .ports = ports,
};
const deserializer = v8.v8__ValueDeserializer__New(local.isolate.handle, bytes.ptr, bytes.len, &.{
.data = &delegate_ctx,
@@ -513,6 +528,11 @@ const cloneable_types = .{
@import("../webapi/webcodecs/VideoFrame.zig"),
};
+const MessagePort = @import("../webapi/MessagePort.zig");
+
+// Tag for a transferred MessagePort, after the cloneable_types tags.
+const transferred_port_tag: u32 = cloneable_types.len;
+
comptime {
// writeHostObject relies on subtypes coming after their prototypes.
for (0..cloneable_types.len) |i| {
@@ -587,11 +607,13 @@ const CloneDelegate = struct {
const SerializeContext = struct {
local: *const js.Local,
serializer: *v8.ValueSerializer,
+ transfer: []const *MessagePort,
};
const DeserializeContext = struct {
local: *const js.Local,
deserializer: *v8.ValueDeserializer,
+ ports: []const *MessagePort,
};
// Called when V8 encounters an object with embedder fields, i.e. one of
@@ -605,6 +627,13 @@ const CloneDelegate = struct {
const obj = object orelse break :blk;
const tao = TaggedOpaque.fromObject(obj) orelse break :blk;
+ if (tao.as(MessagePort)) |port| {
+ const index = std.mem.findScalar(*MessagePort, ctx.transfer, port) orelse break :blk;
+ v8.v8__ValueSerializer__WriteUint32(ctx.serializer, transferred_port_tag);
+ v8.v8__ValueSerializer__WriteUint32(ctx.serializer, @intCast(index));
+ return .{ .has_value = true, .value = true };
+ }
+
// Serialize as the closest cloneable type: subtypes are listed
// after their prototypes, so the last match is the closest.
inline for (0..cloneable_types.len) |i| {
@@ -637,6 +666,12 @@ const CloneDelegate = struct {
var tag: u32 = undefined;
if (v8.v8__ValueDeserializer__ReadUint32(ctx.deserializer, &tag)) {
+ if (tag == transferred_port_tag) {
+ return readTransferredPort(ctx) orelse {
+ throwDataCloneException(local, null);
+ return null;
+ };
+ }
var reader = StructuredReader{ .local = local, .deserializer = ctx.deserializer };
inline for (cloneable_types, 0..) |T, i| {
if (tag == i) {
@@ -652,6 +687,18 @@ const CloneDelegate = struct {
return null;
}
+ fn readTransferredPort(ctx: *DeserializeContext) ?*const v8.Object {
+ var index: u32 = undefined;
+ if (!v8.v8__ValueDeserializer__ReadUint32(ctx.deserializer, &index)) {
+ return null;
+ }
+ if (index >= ctx.ports.len) {
+ return null;
+ }
+ const js_obj = ctx.local.mapZigInstanceToJs(null, ctx.ports[index]) catch return null;
+ return js_obj.handle;
+ }
+
fn readCloneable(comptime T: type, reader: *StructuredReader) ?*const v8.Object {
const local = reader.local;
const instance = T.structuredDeserialize(reader, local.ctx.page) catch return null;
diff --git a/src/browser/tests/message_channel.html b/src/browser/tests/message_channel.html
index 12c5e5cc9..f95268ed3 100644
--- a/src/browser/tests/message_channel.html
+++ b/src/browser/tests/message_channel.html
@@ -103,4 +103,187 @@
}
</script>
+<script id="transfer" type=module>
+ const state = await testing.async();
+
+ // a port nested in the message and listed in transfer arrives as the moved
+ // port, in both e.data and e.ports
+ const carrier = new MessageChannel();
+ const inner = new MessageChannel();
+ const received = await new Promise((resolve) => {
+ carrier.port2.onmessage = (e) => resolve(e);
+ carrier.port1.postMessage({ port: inner.port2 }, [inner.port2]);
+ });
+
+ // the moved port stays entangled with inner.port1
+ const echoed = await new Promise((resolve) => {
+ inner.port1.onmessage = (e) => resolve(e.data);
+ received.data.port.postMessage('through moved port');
+ });
+
+ // StructuredSerializeOptions form
+ const viaOptions = new MessageChannel();
+ const optionsEvent = await new Promise((resolve) => {
+ carrier.port2.onmessage = (e) => resolve(e);
+ carrier.port1.postMessage('opts', { transfer: [viaOptions.port1] });
+ });
+
+ state.resolve();
+ await state.done(() => {
+ testing.expectEqual(1, received.ports.length);
+ testing.expectEqual(true, received.ports[0] === received.data.port);
+ testing.expectEqual(false, received.data.port === inner.port2);
+ testing.expectEqual('through moved port', echoed);
+
+ testing.expectEqual('opts', optionsEvent.data);
+ testing.expectEqual(1, optionsEvent.ports.length);
+ });
+</script>
+
+<script id="transfer-errors" type=module>
+ function dataCloneError(fn) {
+ try {
+ fn();
+ } catch (e) {
+ return e.name;
+ }
+ return 'no error';
+ }
+
+ const channel = new MessageChannel();
+ const other = new MessageChannel();
+
+ // a port in the message must be in the transfer list
+ testing.expectEqual('DataCloneError', dataCloneError(() => channel.port1.postMessage(other.port1)));
+ // a port can't transfer itself
+ testing.expectEqual('DataCloneError', dataCloneError(() => channel.port1.postMessage(null, [channel.port1])));
+ // duplicates
+ testing.expectEqual('DataCloneError', dataCloneError(() => channel.port1.postMessage(null, [other.port1, other.port1])));
+ // non-transferable
+ testing.expectEqual('DataCloneError', dataCloneError(() => channel.port1.postMessage(null, [{}])));
+
+ // once transferred, a port is detached and can't be transferred again
+ channel.port1.postMessage(null, [other.port1]);
+ testing.expectEqual('DataCloneError', dataCloneError(() => channel.port1.postMessage(null, [other.port1])));
+</script>
+
+<script id="window-transfer" type=module>
+ const state = await testing.async();
+
+ const channel = new MessageChannel();
+ const event = await new Promise((resolve) => {
+ window.addEventListener('message', function listener(e) {
+ if (e.data && e.data.port) {
+ window.removeEventListener('message', listener);
+ resolve(e);
+ }
+ });
+ window.postMessage({ port: channel.port2 }, '*', [channel.port2]);
+ });
+
+ const echoed = await new Promise((resolve) => {
+ channel.port1.onmessage = (e) => resolve(e.data);
+ event.data.port.postMessage('from window message');
+ });
+
+ state.resolve();
+ await state.done(() => {
+ testing.expectEqual(true, event.ports[0] === event.data.port);
+ testing.expectEqual('from window message', echoed);
+ });
+</script>
+
+<script id="transfer-in-flight" type=module>
+ const state = await testing.async();
+
+ // port2 is started, so 'first' and 'second' are already scheduled for
+ // delivery when port2 is transferred: they follow it, ahead of 'third'
+ const channel = new MessageChannel();
+ const carrier = new MessageChannel();
+ const lost = [];
+ channel.port2.onmessage = (e) => lost.push(e.data);
+ channel.port1.postMessage('first');
+ channel.port1.postMessage('second');
+
+ const moved = await new Promise((resolve) => {
+ carrier.port2.onmessage = (e) => resolve(e.ports[0]);
+ carrier.port1.postMessage(null, [channel.port2]);
+ });
+ channel.port1.postMessage('third');
+
+ const received = [];
+ await new Promise((resolve) => {
+ moved.onmessage = (e) => {
+ received.push(e.data);
+ if (received.length === 3) resolve();
+ };
+ });
+
+ state.resolve();
+ await state.done(() => {
+ testing.expectEqual(0, lost.length);
+ testing.expectEqual('first,second,third', received.join(','));
+ });
+</script>
+
+<script id="transfer-closed-port" type=module>
+ // a closed (disentangled) port still serializes: bad data throws and the
+ // transferred ports detach
+ const channel = new MessageChannel();
+ channel.port1.close();
+
+ let name = 'no error';
+ try {
+ channel.port1.postMessage(Symbol());
+ } catch (e) {
+ name = e.name;
+ }
+ testing.expectEqual('DataCloneError', name);
+
+ const other = new MessageChannel();
+ channel.port1.postMessage(null, [other.port1]);
+ name = 'no error';
+ try {
+ channel.port1.postMessage(null, [other.port1]);
+ } catch (e) {
+ name = e.name;
+ }
+ testing.expectEqual('DataCloneError', name);
+</script>
+
+<script id="window-transfer-forms" type=module>
+ const state = await testing.async();
+
+ // other scripts post to window too; only take the message that matches
+ function nextMessage(match) {
+ return new Promise((resolve) => {
+ window.addEventListener('message', function listener(e) {
+ if (match(e.data)) {
+ window.removeEventListener('message', listener);
+ resolve(e);
+ }
+ });
+ });
+ }
+
+ // an ArrayBuffer in the transfer list is accepted
+ const buffer = new Uint8Array([1, 2, 3]).buffer;
+ const bufferPromise = nextMessage((data) => data instanceof ArrayBuffer);
+ window.postMessage(buffer, '*', [buffer]);
+ const bufferEvent = await bufferPromise;
+
+ // the options form carries its transfer list
+ const channel = new MessageChannel();
+ const optionsPromise = nextMessage((data) => data === 'opts');
+ window.postMessage('opts', { targetOrigin: '*', transfer: [channel.port2] });
+ const optionsEvent = await optionsPromise;
+
+ state.resolve();
+ await state.done(() => {
+ testing.expectEqual(3, bufferEvent.data.byteLength);
+ testing.expectEqual('opts', optionsEvent.data);
+ testing.expectEqual(1, optionsEvent.ports.length);
+ });
+</script>
+
</body>
diff --git a/src/browser/tests/worker/port-worker.js b/src/browser/tests/worker/port-worker.js
new file mode 100644
index 000000000..74f37e848
--- /dev/null
+++ b/src/browser/tests/worker/port-worker.js
@@ -0,0 +1,12 @@
+// Comlink-style: replies through a port transferred in with the message, then
+// hands a port of its own back to the page.
+onmessage = function(event) {
+ const port = event.data.port;
+ port.onmessage = (e) => {
+ port.postMessage({ echo: e.data, ports: event.ports.length, same: event.ports[0] === port });
+ };
+
+ const back = new MessageChannel();
+ back.port1.onmessage = (e) => postMessage({ back: e.data });
+ postMessage({ port: back.port2 }, [back.port2]);
+};
diff --git a/src/browser/tests/worker/worker.html b/src/browser/tests/worker/worker.html
index 778474552..69df173f7 100644
--- a/src/browser/tests/worker/worker.html
+++ b/src/browser/tests/worker/worker.html
@@ -1,5 +1,47 @@
<!DOCTYPE html>
-<body></body>
+<body><script id="worker_transfer_port" type=module>
+ {
+ const state = await testing.async();
+ const worker = new Worker('./port-worker.js');
+
+ const channel = new MessageChannel();
+ // queued before the transfer: moves with port2 into the worker
+ channel.port1.postMessage('early');
+
+ const replies = [];
+ channel.port1.onmessage = (e) => {
+ replies.push(e.data);
+ if (replies.length === 1) {
+ channel.port1.postMessage('late');
+ } else {
+ // the worker transferred a port of its own back to us
+ workerPort.postMessage('to worker');
+ }
+ };
+
+ let workerPort = null;
+ worker.onmessage = (e) => {
+ if (e.data.port) {
+ workerPort = e.data.port;
+ } else {
+ state.resolve({ replies, back: e.data.back, ports: e.ports.length });
+ }
+ };
+
+ worker.postMessage({ port: channel.port2 }, [channel.port2]);
+
+ await state.done((result) => {
+ testing.expectEqual(2, result.replies.length);
+ testing.expectEqual('early', result.replies[0].echo);
+ testing.expectEqual(1, result.replies[0].ports);
+ testing.expectEqual(true, result.replies[0].same);
+ testing.expectEqual('late', result.replies[1].echo);
+ testing.expectEqual('to worker', result.back);
+ testing.expectEqual(0, result.ports);
+ });
+ }
+</script>
+</body>
<script src="../testing.js"></script>
<script id="worker_creation">
diff --git a/src/browser/webapi/DedicatedWorkerGlobalScope.zig b/src/browser/webapi/DedicatedWorkerGlobalScope.zig
index d0b2ad8f3..5ffd91743 100644
--- a/src/browser/webapi/DedicatedWorkerGlobalScope.zig
+++ b/src/browser/webapi/DedicatedWorkerGlobalScope.zig
@@ -29,6 +29,7 @@ const lp = @import("lightpanda");
const js = @import("../js/js.zig");
const EventTarget = @import("EventTarget.zig");
+const MessagePort = @import("MessagePort.zig");
const Worker = @import("Worker.zig");
const WorkerGlobalScope = @import("WorkerGlobalScope.zig");
@@ -47,7 +48,7 @@ _closed: bool = false,
// and delivered once the worker is ready (i.e. once onmessage can be set).
// Drained by drainPendingMessages, called from Worker.loadInitialScript
// after the initial script has been evaluated.
-_pending_messages: std.ArrayList(?js.Value.Global) = .empty,
+_pending_messages: std.ArrayList(MessagePort.Message) = .empty,
pub fn init(worker: *Worker, url: [:0]const u8) !*DedicatedWorkerGlobalScope {
return WorkerGlobalScope.init(
@@ -66,16 +67,14 @@ pub fn init(worker: *Worker, url: [:0]const u8) !*DedicatedWorkerGlobalScope {
}
pub fn deinit(self: *DedicatedWorkerGlobalScope) void {
- for (self._pending_messages.items) |maybe_data| {
- if (maybe_data) |d| {
- d.release();
- }
+ for (self._pending_messages.items) |message| {
+ message.release();
}
self._proto.deinit();
}
-pub fn postMessage(self: *DedicatedWorkerGlobalScope, data: js.Value) !void {
- try self._worker.receiveMessage(data);
+pub fn postMessage(self: *DedicatedWorkerGlobalScope, data: js.Value, transfer: ?js.Value) !void {
+ try self._worker.receiveMessage(data, try MessagePort.transferList(transfer));
}
pub fn close(self: *DedicatedWorkerGlobalScope) void {
@@ -99,21 +98,16 @@ pub fn cancelAnimationFrame(self: *DedicatedWorkerGlobalScope, id: u32) void {
}
// Called internally by Worker when it wants to post a message to us
-pub fn receiveMessage(self: *DedicatedWorkerGlobalScope, data: js.Value) !void {
+pub fn receiveMessage(self: *DedicatedWorkerGlobalScope, data: js.Value, transfer: []const *MessagePort) !void {
+ // clones from where it currently is (the Worker's Page context) to our Context.
+ // Done even when closed (per spec), so transferred ports still detach and
+ // bad data still throws.
+ const cloned_data = try MessagePort.cloneMessage(data, transfer, &self._proto.js.execution);
if (self._closed) {
+ cloned_data.release();
return;
}
-
- const cloned_data: ?js.Value.Global = blk: {
- // Enter our context to clone the message
- var ls: js.Local.Scope = undefined;
- self._proto.js.localScope(&ls);
- defer ls.deinit();
-
- // clones from where it currently is (the Worker's Page context) to our Context
- const cloned = data.structuredCloneTo(&ls.local) catch break :blk null;
- break :blk cloned.persist() catch break :blk null;
- };
+ errdefer cloned_data.release();
if (!self._worker._script_loaded) {
// Buffer until Worker.loadInitialScript calls drainPendingMessages.
@@ -128,7 +122,7 @@ pub fn receiveMessage(self: *DedicatedWorkerGlobalScope, data: js.Value) !void {
try self.scheduleMessage(cloned_data);
}
-fn scheduleMessage(self: *DedicatedWorkerGlobalScope, cloned_data: ?js.Value.Global) !void {
+fn scheduleMessage(self: *DedicatedWorkerGlobalScope, cloned_data: MessagePort.Message) !void {
const wgs = self._proto;
const session = wgs._session;
@@ -156,22 +150,20 @@ pub fn drainPendingMessages(self: *DedicatedWorkerGlobalScope) void {
for (self._pending_messages.items) |cloned_data| {
self.scheduleMessage(cloned_data) catch |err| {
lp.log.debug(.browser, "worker drain msg failed", .{ .err = err });
- if (cloned_data) |d| d.release();
+ cloned_data.release();
};
}
self._pending_messages.clearRetainingCapacity();
}
const ReceiveMessageCallback = struct {
- data: ?js.Value.Global,
+ data: MessagePort.Message,
arena: *lp.Arena,
worker_scope: *DedicatedWorkerGlobalScope,
fn cancelled(ctx: *anyopaque) void {
const self: *ReceiveMessageCallback = @ptrCast(@alignCast(ctx));
- if (self.data) |d| {
- d.release();
- }
+ self.data.release();
self.deinit();
}
@@ -182,32 +174,35 @@ const ReceiveMessageCallback = struct {
fn run(ctx: *anyopaque) !?u32 {
const self: *ReceiveMessageCallback = @ptrCast(@alignCast(ctx));
defer self.deinit();
+ defer self.data.releasePorts();
const worker_scope = self.worker_scope;
const wsg = worker_scope._proto;
const target = wsg.asEventTarget();
- // If data is null, structured clone failed - fire messageerror
- if (self.data == null) {
+ // If data is null, deserialization failed - fire messageerror
+ const data = self.data.data orelse {
if (!wsg._event_manager.hasDirectListeners(target, "messageerror")) {
return null;
}
const event = (try MessageEvent.initTrusted(comptime .wrap("messageerror"), .{
+ .ports = self.data.ports,
.bubbles = false,
.cancelable = false,
}, wsg.page)).asEvent();
try wsg.dispatch(target, event, .{});
return null;
- }
+ };
// Check if there are any listeners before creating the event
if (!wsg._event_manager.hasDirectListeners(target, "message")) {
- self.data.?.release();
+ data.release();
return null;
}
const event = (try MessageEvent.initTrusted(comptime .wrap("message"), .{
- .data = .{ .value = self.data.? },
+ .data = .{ .value = data },
+ .ports = self.data.ports,
.bubbles = false,
.cancelable = false,
}, wsg.page)).asEvent();
diff --git a/src/browser/webapi/MessagePort.zig b/src/browser/webapi/MessagePort.zig
index 84fa8f667..e316c35d9 100644
--- a/src/browser/webapi/MessagePort.zig
+++ b/src/browser/webapi/MessagePort.zig
@@ -38,10 +38,17 @@ _proto: *EventTarget,
_exec: *Execution,
_enabled: bool = false,
_closed: bool = false,
+
+// set once transfered to another context
+_detached: bool = false,
_entangled_port: ?*MessagePort = null,
// queued message received before the port is started.
-_pending: std.ArrayList(js.Value.Global) = .empty,
+_pending: std.ArrayList(Message) = .empty,
+
+// DeliverCallbacks scheduled but not yet run, in order. A transfer takes their
+// messages along to the new port.
+_in_flight: std.DoublyLinkedList = .{},
// Link list into the owning Frame or WorkerGlobalScope. When the frame/WGS is
// shutdown, the port will be closed.
@@ -65,45 +72,211 @@ pub fn entangle(port1: *MessagePort, port2: *MessagePort) void {
port2._entangled_port = port1;
}
-pub fn postMessage(self: *MessagePort, message: js.Value) !void {
- if (self._closed) {
+pub fn postMessage(self: *MessagePort, message: js.Value, transfer: ?js.Value) !void {
+ const ports = try transferList(transfer);
+ if (std.mem.findScalar(*MessagePort, ports, self) != null) {
+ return error.DataClone;
+ }
+
+ const other: ?*MessagePort = if (self._closed) null else self._entangled_port;
+
+ // With no live receiver, or when the receiving port is itself being
+ // transferred, the message is doomed. It's still serialized (per spec), so
+ // the transferred ports detach and bad data throws, but nothing is
+ // delivered.
+ var doomed = true;
+ if (other) |o| {
+ doomed = o._closed or std.mem.findScalar(*MessagePort, ports, o) != null;
+ }
+
+ // The clone is made directly into the receiving port's context, which may
+ // not be the sender's.
+ const target_exec = if (other) |o| o._exec else self._exec;
+ const cloned = try cloneMessage(message, ports, target_exec);
+ if (doomed) {
+ cloned.release();
return;
}
+ errdefer cloned.release();
- const other = self._entangled_port orelse return;
- if (other._closed) {
+ const receiver = other.?;
+ if (!receiver._enabled) {
+ try receiver._pending.append(receiver._exec.page_arena, cloned);
return;
}
- // StructuredSerialize runs synchronously (per spec): clone the message now
- // so the receiver gets an independent copy (a mutation on one side isn't
- // visible to the other) and an unserializable value throws a DataCloneError
- // to the caller. The clone is made directly into the receiving port's
- // context, which may not be the sender's.
- const cloned = blk: {
- var ls: js.Local.Scope = undefined;
- other._exec.js.localScope(&ls);
- defer ls.deinit();
+ try receiver.scheduleDelivery(cloned);
+}
- // Contain any V8 exception from a failed serialization so it surfaces as
- // a clean DataCloneError; deinit() (no rethrow) clears it.
+// A message cloned into the receiving context. `data` is null when it couldn't
+// be deserialized there, which the receiver reports as a messageerror.
+pub const Message = struct {
+ data: ?js.Value.Global,
+ // The transferred ports, already moved into the receiving context.
+ ports: []const *MessagePort,
+ // Owns `ports`; null when there are none.
+ ports_arena: ?*lp.Arena = null,
+
+ // For a message that's dropped.
+ pub fn release(self: Message) void {
+ if (self.data) |d| {
+ d.release();
+ }
+ self.releasePorts();
+ }
+
+ // For a message that's delivered: the event owns `data` and has copied
+ // `ports`.
+ pub fn releasePorts(self: Message) void {
+ if (self.ports_arena) |arena| {
+ arena.release();
+ }
+ }
+};
+
+// StructuredSerializeWithTransfer in the sender's realm, then
+// StructuredDeserializeWithTransfer in `target`'s, done back to back since
+// every realm lives in the same isolate. Serialization runs synchronously (per
+// spec) so an unserializable value throws a DataCloneError to the sender, and
+// the receiver gets an independent copy. Each port in `transfer` moves to
+// `target`; one nested in `message` comes out as its moved counterpart.
+pub fn cloneMessage(message: js.Value, transfer: []const *MessagePort, target: *Execution) !Message {
+ for (transfer, 0..) |port, i| {
+ if (port._detached or std.mem.findScalar(*MessagePort, transfer[0..i], port) != null) {
+ return error.DataClone;
+ }
+ }
+
+ const serialized = blk: {
+ // Contain any V8 exception from a failed serialization so it surfaces
+ // as a clean DataCloneError; deinit() (no rethrow) clears it.
var try_catch: js.TryCatch = undefined;
- try_catch.init(&ls.local);
+ try_catch.init(message.local);
defer try_catch.deinit();
+ break :blk message.serializeTransfer(transfer) catch return error.DataClone;
+ };
+ defer serialized.deinit();
+
+ var ports: []*MessagePort = &.{};
+ var ports_arena: ?*lp.Arena = null;
+ errdefer if (ports_arena) |arena| arena.release();
+ if (transfer.len > 0) {
+ const arena = try target.getArena(.tiny, "MessagePort.Message");
+ ports_arena = arena;
+ ports = try arena.allocator().alloc(*MessagePort, transfer.len);
+ }
+ for (transfer, ports) |port, *moved| {
+ moved.* = try port.transferTo(target);
+ }
- const c = message.structuredCloneTo(&ls.local) catch {
- return error.DataClone;
- };
- break :blk try c.persist();
+ var ls: js.Local.Scope = undefined;
+ target.js.localScope(&ls);
+ defer ls.deinit();
+
+ var try_catch: js.TryCatch = undefined;
+ try_catch.init(&ls.local);
+ defer try_catch.deinit();
+
+ const value = js.Value.deserializeTransfer(&ls.local, serialized.bytes(), ports) catch {
+ return .{ .data = null, .ports = ports, .ports_arena = ports_arena };
};
- errdefer cloned.release();
+ return .{ .data = try value.persist(), .ports = ports, .ports_arena = ports_arena };
+}
- if (!other._enabled) {
- try other._pending.append(other._exec.page_arena, cloned);
- return;
+// The `transfer` argument of postMessage: a sequence of transferables, or a
+// StructuredSerializeOptions dictionary. Only MessagePorts move; an
+// ArrayBuffer is accepted but left attached (the clone copies it).
+pub fn transferList(arg: ?js.Value) ![]const *MessagePort {
+ const value = arg orelse return &.{};
+ if (value.isNullOrUndefined()) {
+ return &.{};
}
+ if (value.isObject() == false) {
+ return error.TypeError;
+ }
+
+ const local = value.local;
+ const list = if (value.isArray()) value else blk: {
+ const t = try value.toObject().get("transfer");
+ if (t.isNullOrUndefined()) {
+ return &.{};
+ }
+ break :blk t;
+ };
- try other.scheduleDelivery(cloned);
+ const items = try local.jsValueToZig([]const js.Value, list);
+ const ports = try local.call_arena.alloc(*MessagePort, items.len);
+ var count: usize = 0;
+ for (items) |item| {
+ if (item.isArrayBuffer()) {
+ continue;
+ }
+ const port = if (item.isObject()) if (item.taggedOpaque()) |tao| tao.as(MessagePort) else null else null;
+ ports[count] = port orelse return error.DataClone;
+ count += 1;
+ }
+ return ports[0..count];
+}
+
+// Moves this port into `exec`: a fresh port there takes over the entanglement
+// and any queued messages, and this one is left detached.
+fn transferTo(self: *MessagePort, exec: *Execution) !*MessagePort {
+ const port = try MessagePort.init(exec);
+
+ if (self._entangled_port) |other| {
+ entangle(port, other);
+ }
+ self._entangled_port = null;
+
+ // Scheduled deliveries were queued before anything still pending (which
+ // only exists if the port was never started), so they go first.
+ while (self._in_flight.popFirst()) |node| {
+ const callback: *DeliverCallback = @fieldParentPtr("node", node);
+ const message = callback.message.?;
+ callback.message = null;
+ port.adoptPending(message, self._exec);
+ }
+ for (self._pending.items) |message| {
+ port.adoptPending(message, self._exec);
+ }
+ self._pending.clearRetainingCapacity();
+
+ if (self._closed) {
+ port.close();
+ }
+ self._detached = true;
+ self.close();
+ return port;
+}
+
+// Queues a message the port's previous incarnation (in `from`) hadn't
+// delivered yet. The new port isn't started, so it waits in _pending.
+fn adoptPending(self: *MessagePort, message: Message, from: *Execution) void {
+ const moved = moveMessage(message, from, self._exec) orelse return;
+ self._pending.append(self._exec.page_arena, moved) catch |err| {
+ log.debug(.dom, "MessagePort transfer", .{ .err = err });
+ moved.release();
+ };
+}
+
+// Re-homes a queued message (and the ports it carries) into another context.
+// Takes ownership of `message`; null if it couldn't be moved.
+fn moveMessage(message: Message, from: *Execution, to: *Execution) ?Message {
+ if (from == to) {
+ return message;
+ }
+ defer message.release();
+
+ const data = message.data orelse return null;
+
+ var ls: js.Local.Scope = undefined;
+ from.js.localScope(&ls);
+ defer ls.deinit();
+
+ return cloneMessage(data.local(&ls.local), message.ports, to) catch |err| {
+ log.debug(.dom, "MessagePort transfer", .{ .err = err });
+ return null;
+ };
}
pub fn start(self: *MessagePort) void {
@@ -142,7 +315,7 @@ pub fn close(self: *MessagePort) void {
// Queues delivery of `message` (a clone already living in this port's
// context) on this port's scheduler.
-fn scheduleDelivery(self: *MessagePort, message: js.Value.Global) !void {
+fn scheduleDelivery(self: *MessagePort, message: Message) !void {
const exec = self._exec;
const callback = try exec._factory.create(DeliverCallback{
.port = self,
@@ -150,6 +323,9 @@ fn scheduleDelivery(self: *MessagePort, message: js.Value.Global) !void {
});
errdefer exec._factory.destroy(callback);
+ self._in_flight.append(&callback.node);
+ errdefer self._in_flight.remove(&callback.node);
+
try exec.js.scheduler.add(callback, DeliverCallback.run, 0, .{
.name = "MessagePort.postMessage",
.finalizer = DeliverCallback.cancelled,
@@ -158,13 +334,19 @@ fn scheduleDelivery(self: *MessagePort, message: js.Value.Global) !void {
const DeliverCallback = struct {
port: *MessagePort,
- message: js.Value.Global,
+ // null once a transfer has taken it to the port's new incarnation (and
+ // unlinked this callback from _in_flight).
+ message: ?Message,
+ node: std.DoublyLinkedList.Node = .{},
// Called by the scheduler if the task is dropped before it runs. `run` and
// `cancelled` are mutually exclusive, so the temp is released exactly once.
fn cancelled(ctx: *anyopaque) void {
const self: *DeliverCallback = @ptrCast(@alignCast(ctx));
- self.message.release();
+ if (self.message) |message| {
+ self.port._in_flight.remove(&self.node);
+ message.release();
+ }
self.deinit();
}
@@ -178,26 +360,49 @@ const DeliverCallback = struct {
const port = self.port;
const exec = port._exec;
+ const message = self.message orelse return null;
+ port._in_flight.remove(&self.node);
+ defer message.releasePorts();
+
// The MessageEvent takes ownership of the cloned temp and releases it on
// teardown; on any path where we don't hand it over, release it here so
// it doesn't leak.
if (port._closed) {
- self.message.release();
+ if (message.data) |d| {
+ d.release();
+ }
return null;
}
const target = port.asEventTarget();
+ const data = message.data orelse {
+ if (exec.hasDirectListeners(target, "messageerror")) {
+ const event = (MessageEvent.initTrusted(comptime .wrap("messageerror"), .{
+ .origin = "",
+ .ports = message.ports,
+ }, exec.page) catch |err| {
+ log.debug(.dom, "MessagePort.postMessage", .{ .err = err });
+ return null;
+ }).asEvent();
+ exec.dispatch(target, event, .{ .context = "MessagePort messageerror" }) catch |err| {
+ log.debug(.dom, "MessagePort.postMessage", .{ .err = err });
+ };
+ }
+ return null;
+ };
+
if (!exec.hasDirectListeners(target, "message")) {
- self.message.release();
+ data.release();
return null;
}
const event = (MessageEvent.initTrusted(comptime .wrap("message"), .{
- .data = .{ .value = self.message },
+ .data = .{ .value = data },
.origin = "",
.source = null,
+ .ports = message.ports,
}, exec.page) catch |err| {
- self.message.release();
+ data.release();
log.debug(.dom, "MessagePort.postMessage", .{ .err = err });
return null;
}).asEvent();
diff --git a/src/browser/webapi/Window.zig b/src/browser/webapi/Window.zig
index 7407d8d24..37fced885 100644
--- a/src/browser/webapi/Window.zig
+++ b/src/browser/webapi/Window.zig
@@ -689,10 +689,17 @@ pub fn stop(self: *Window) void {
self._frame.stopLoading();
}
-pub fn postMessage(self: *Window, message: js.Value, target_origin: ?[]const u8, transfer: ?[]const *MessagePort, frame: *Frame) !void {
+// postMessage(message, targetOrigin, transfer) or postMessage(message, options).
+pub fn postMessage(self: *Window, message: js.Value, target_origin_or_options: ?js.Value, transfer: ?js.Value, frame: *Frame) !void {
// For now, we ignore targetOrigin checking and just dispatch the message
// In a full implementation, we would validate the origin
- _ = target_origin;
+ var transfer_arg = transfer;
+ if (target_origin_or_options) |arg| {
+ if (arg.isObject()) {
+ transfer_arg = arg;
+ }
+ }
+ const ports = try MessagePort.transferList(transfer_arg);
const target_frame = self._frame;
const source_window = target_frame.js.getIncumbent().window;
@@ -700,27 +707,10 @@ pub fn postMessage(self: *Window, message: js.Value, target_origin: ?[]const u8,
const arena = try target_frame.getArena(.medium, "Window.postMessage");
errdefer arena.release();
- // StructuredSerialize runs synchronously (per spec): clone the message into
- // the target window's realm now. The receiver gets a fresh, independent copy
- // minted in its own realm (not the source realm's object), an unserializable
- // value throws a DataCloneError to the caller, and the source-realm temp
- // doesn't leak into the destination context. Mirrors Worker.postMessage.
- const cloned = blk: {
- var ls: js.Local.Scope = undefined;
- target_frame.js.localScope(&ls);
- defer ls.deinit();
-
- // Contain any V8 exception from a failed serialization so it surfaces as
- // a clean DataCloneError; deinit() (no rethrow) clears it.
- var try_catch: js.TryCatch = undefined;
- try_catch.init(&ls.local);
- defer try_catch.deinit();
-
- const c = message.structuredCloneTo(&ls.local) catch {
- return error.DataClone;
- };
- break :blk try c.persist();
- };
+ // Clone the message into the target window's realm now: the receiver gets
+ // a fresh copy minted in its own realm, and the transferred ports move
+ // there. Mirrors Worker.postMessage.
+ const cloned = try MessagePort.cloneMessage(message, ports, &target_frame.js.execution);
errdefer cloned.release();
// Origin should be the source window's origin (where the message came from)
@@ -732,7 +722,6 @@ pub fn postMessage(self: *Window, message: js.Value, target_origin: ?[]const u8,
.frame = target_frame,
.source = source_window,
.origin = try arena.dupe(u8, origin),
- .ports = if (transfer) |t| try arena.dupe(*MessagePort, t) else &.{},
};
try target_frame.js.scheduler.add(callback, PostMessageCallback.run, 0, .{
@@ -963,8 +952,7 @@ const PostMessageCallback = struct {
source: *Window,
arena: *lp.Arena,
origin: []const u8,
- message: js.Value.Global,
- ports: []const *MessagePort,
+ message: MessagePort.Message,
fn deinit(self: *PostMessageCallback) void {
self.arena.release();
@@ -981,24 +969,39 @@ const PostMessageCallback = struct {
fn run(ctx: *anyopaque) !?u32 {
const self: *PostMessageCallback = @ptrCast(@alignCast(ctx));
defer self.deinit();
+ defer self.message.releasePorts();
const frame = self.frame;
const window = frame.window;
const event_target = window.asEventTarget();
+ const data = self.message.data orelse {
+ if (frame._event_manager.hasDirectListeners(event_target, "messageerror")) {
+ const event = (try MessageEvent.initTrusted(comptime .wrap("messageerror"), .{
+ .origin = self.origin,
+ .source = .{ .window = self.source },
+ .ports = self.message.ports,
+ .bubbles = false,
+ .cancelable = false,
+ }, frame.page)).asEvent();
+ try frame._event_manager.dispatchDirect(event_target, event, .{ .context = "window.postMessage" });
+ }
+ return null;
+ };
+
// The MessageEvent takes ownership of the cloned temp and releases it on
// teardown; if there are no listeners, release it here so it doesn't leak.
if (!frame._event_manager.hasDirectListeners(event_target, "message")) {
- self.message.release();
+ data.release();
return null;
}
const event = (try MessageEvent.initTrusted(comptime .wrap("message"), .{
- .data = .{ .value = self.message },
+ .data = .{ .value = data },
.origin = self.origin,
.source = .{ .window = self.source },
- .ports = self.ports,
+ .ports = self.message.ports,
.bubbles = false,
.cancelable = false,
}, frame.page)).asEvent();
@@ -1267,8 +1270,8 @@ pub const JsApi = struct {
const CrossOriginWindow = struct {
window: *Window,
- pub fn postMessage(self: *CrossOriginWindow, message: js.Value, target_origin: ?[]const u8, transfer: ?[]const *MessagePort, frame: *Frame) !void {
- return self.window.postMessage(message, target_origin, transfer, frame);
+ pub fn postMessage(self: *CrossOriginWindow, message: js.Value, target_origin_or_options: ?js.Value, transfer: ?js.Value, frame: *Frame) !void {
+ return self.window.postMessage(message, target_origin_or_options, transfer, frame);
}
pub fn getTop(self: *CrossOriginWindow, frame: *Frame) Access {
diff --git a/src/browser/webapi/Worker.zig b/src/browser/webapi/Worker.zig
index 2353e2d74..a05c676f0 100644
--- a/src/browser/webapi/Worker.zig
+++ b/src/browser/webapi/Worker.zig
@@ -26,6 +26,7 @@ const Frame = @import("../Frame.zig");
const Transfer = @import("../../network/HttpClient.zig").Transfer;
const EventTarget = @import("EventTarget.zig");
+const MessagePort = @import("MessagePort.zig");
const MessageEvent = @import("event/MessageEvent.zig");
const ErrorEvent = @import("event/ErrorEvent.zig");
const DedicatedWorkerGlobalScope = @import("DedicatedWorkerGlobalScope.zig");
@@ -332,22 +333,17 @@ pub fn terminate(self: *Worker) void {
}
// Posts a message from the frame to the worker.
-pub fn postMessage(self: *Worker, data: js.Value) !void {
- try self._worker_scope.receiveMessage(data);
+pub fn postMessage(self: *Worker, data: js.Value, transfer: ?js.Value) !void {
+ try self._worker_scope.receiveMessage(data, try MessagePort.transferList(transfer));
}
// Called internally by DedicatedWorkerGlobalScope when it wants to post a message to us
-pub fn receiveMessage(self: *Worker, data: js.Value) !void {
+pub fn receiveMessage(self: *Worker, data: js.Value, transfer: []const *MessagePort) !void {
const frame = self._frame;
- const cloned_data = blk: {
- var ls: js.Local.Scope = undefined;
- frame.js.localScope(&ls);
- defer ls.deinit();
-
- // clones from where it currently is (the Worker context) to our Page's context
- const cloned = data.structuredCloneTo(&ls.local) catch |err| break :blk err;
- break :blk cloned.persist();
- };
+
+ // clones from where it currently is (the Worker context) to our Page's context
+ const message = try MessagePort.cloneMessage(data, transfer, &frame.js.execution);
+ errdefer message.release();
const message_arena = try frame.getArena(.tiny, "Worker.receiveMessage");
errdefer message_arena.release();
@@ -355,7 +351,7 @@ pub fn receiveMessage(self: *Worker, data: js.Value) !void {
const callback = try message_arena.create(ReceiveMessageCallback);
callback.* = .{
.worker = self,
- .data = cloned_data,
+ .message = message,
.arena = message_arena,
};
@@ -366,15 +362,13 @@ pub fn receiveMessage(self: *Worker, data: js.Value) !void {
}
const ReceiveMessageCallback = struct {
- data: anyerror!js.Value.Global,
+ message: MessagePort.Message,
arena: *lp.Arena,
worker: *Worker,
fn cancelled(ctx: *anyopaque) void {
const self: *ReceiveMessageCallback = @ptrCast(@alignCast(ctx));
- if (self.data) |d| {
- d.release();
- } else |_| {}
+ self.message.release();
self.deinit();
}
@@ -385,18 +379,19 @@ const ReceiveMessageCallback = struct {
fn run(ctx: *anyopaque) !?u32 {
const self: *ReceiveMessageCallback = @ptrCast(@alignCast(ctx));
defer self.deinit();
+ defer self.message.releasePorts();
const worker = self.worker;
const frame = worker._frame;
const target = worker.asEventTarget();
- // If data is null, structured clone failed - fire messageerror
- const data = self.data catch |err| {
+ // If data is null, deserialization failed - fire messageerror
+ const data = self.message.data orelse {
if (!frame._event_manager.hasDirectListeners(target, "messageerror")) {
return null;
}
const event = (try MessageEvent.initTrusted(comptime .wrap("messageerror"), .{
- .data = .{ .string = @errorName(err) },
+ .ports = self.message.ports,
.bubbles = false,
.cancelable = false,
}, frame.page)).asEvent();
@@ -412,6 +407,7 @@ const ReceiveMessageCallback = struct {
const event = (try MessageEvent.initTrusted(comptime .wrap("message"), .{
.data = .{ .value = data },
+ .ports = self.message.ports,
.bubbles = false,
.cancelable = false,
}, frame.page)).asEvent();