Lightpanda: the headless browser designed for AI and automation
mem: don't dupe ReadableStream chunks into page arena
Karl Seguinc70819023de5
diff --git a/src/browser/webapi/compression/zlib.zig b/src/browser/webapi/compression/zlib.zigindex 5e96dd8f6..970213ee7 100644--- a/src/browser/webapi/compression/zlib.zig+++ b/src/browser/webapi/compression/zlib.zig@@ -100,7 +100,7 @@ pub fn Deflate(comptime mode: enum(u1) { compress, decompress }) type {return self.exec.js.typeError(message);}- const FeedError = error{ StreamNotReadable, OutOfMemory, HasJunkData, InvalidData };+ const FeedError = error{ StreamNotReadable, OutOfMemory, CreateObjectFailure, HasJunkData, InvalidData };fn feed(self: *Deflate(mode),diff --git a/src/browser/webapi/streams/ReadableStream.zig b/src/browser/webapi/streams/ReadableStream.zigindex 3fc52d9cf..1377062e4 100644--- a/src/browser/webapi/streams/ReadableStream.zig+++ b/src/browser/webapi/streams/ReadableStream.zig@@ -165,26 +165,19 @@ pub fn collectBodyBytes(self: *ReadableStream, arena: std.mem.Allocator) ![]consvar buf = std.Io.Writer.Allocating.init(arena);const queue = &self._controller._queue;for (queue.items) |chunk| {- const bytes: []const u8 = switch (chunk) {- .string => |s| s,- .uint8array => |arr| arr.values,- .js_value => |global| blk: {- const value = local.toLocal(global);- // toStringSmart falls back to toString(), which would turn a- // stray number or object into "42" / "[object Object]" bytes.- if (value.isString() == null and !value.isTypedArray() and- !value.isArrayBufferView() and !value.isArrayBuffer())- {- return error.TypeError;- }- break :blk try value.toStringSmart();- },- };- try buf.writer.writeAll(bytes);+ const value = local.toLocal(chunk);+ // toStringSmart falls back to toString(), which would turn a+ // stray number or object into "42" / "[object Object]" bytes.+ if (value.isString() == null and !value.isTypedArray() and+ !value.isArrayBufferView() and !value.isArrayBuffer())+ {+ return error.TypeError;+ }+ try buf.writer.writeAll(try value.toStringSmart());}self._collected = true;- queue.clearRetainingCapacity();+ self._controller.clearQueue();return buf.written();}@@ -280,7 +273,7 @@ pub fn cancel(self: *ReadableStream, reason: ?[]const u8, exec: *const Execution}self._state = .closed;- self._controller._queue.clearRetainingCapacity();+ self._controller.clearQueue();const result = ReadableStreamDefaultReader.ReadResult{.done = true,@@ -288,6 +281,7 @@ pub fn cancel(self: *ReadableStream, reason: ?[]const u8, exec: *const Execution};for (self._controller._pending_reads.items) |r| {local.toLocal(r).resolve("stream cancelled", result);+ r.release();}self._controller._pending_reads.clearRetainingCapacity();resolver.resolve("ReadableStream.cancel", {});diff --git a/src/browser/webapi/streams/ReadableStreamDefaultController.zig b/src/browser/webapi/streams/ReadableStreamDefaultController.zigindex aff7840e7..015a939da 100644--- a/src/browser/webapi/streams/ReadableStreamDefaultController.zig+++ b/src/browser/webapi/streams/ReadableStreamDefaultController.zig@@ -30,24 +30,14 @@ const Execution = js.Execution;const ReadableStreamDefaultController = @This();pub const Chunk = union(enum) {- // the order matters, sorry.uint8array: js.TypedArray(u8),string: []const u8,- js_value: js.Value.Global,-- pub fn dupe(self: Chunk, allocator: std.mem.Allocator) !Chunk {- return switch (self) {- .string => |str| .{ .string = try allocator.dupe(u8, str) },- .uint8array => |arr| .{ .uint8array = try arr.dupe(allocator) },- .js_value => |val| .{ .js_value = val },- };- }};_stream: *ReadableStream,_execution: *const Execution,_arena: std.mem.Allocator,-_queue: std.ArrayList(Chunk),+_queue: std.ArrayList(js.Value.Global),_pending_reads: std.ArrayList(js.PromiseResolver.Global),_high_water_mark: u32,@@ -77,8 +67,11 @@ pub fn enqueueNoSideEffects(self: *ReadableStreamDefaultController, chunk: Chunkif (self._stream._state != .readable) {return error.StreamNotReadable;}- const chunk_copy = try chunk.dupe(self._arena);- return self._queue.append(self._arena, chunk_copy);++ var ls: js.Local.Scope = undefined;+ self._execution.js.localScope(&ls);+ defer ls.deinit();+ try self.queueValue(try chunkToJs(&ls.local, chunk));}/// Resolves pending reads with queued chunks. Pairs with `enqueueNoSideEffects`.@@ -98,15 +91,14 @@ pub fn fulfillPendingReads(self: *ReadableStreamDefaultController) void {while (self._pending_reads.items.len > 0 and self._queue.items.len > 0) {const resolver = self._pending_reads.orderedRemove(0);const chunk = self._queue.orderedRemove(0);- const result = ReadableStreamDefaultReader.ReadResult{- .done = false,- .value = .fromChunk(chunk),- };var ls: js.Local.Scope = undefined;exec.js.localScope(&ls);defer ls.deinit();- ls.toLocal(resolver).resolve("stream fulfill pending read", result);++ const value = ls.toLocal(chunk);+ chunk.release();+ resolveRead(&ls.local, resolver, value, "stream fulfill pending read");}}@@ -115,32 +107,10 @@ pub fn enqueue(self: *ReadableStreamDefaultController, chunk: Chunk) !void {return error.StreamNotReadable;}- const exec = self._execution;- if (self._pending_reads.items.len == 0) {- const chunk_copy = try chunk.dupe(self._arena);- return self._queue.append(self._arena, chunk_copy);- }-- // I know, this is ouch! But we expect to have very few (if any)- // pending reads.- const resolver = self._pending_reads.orderedRemove(0);- const result = ReadableStreamDefaultReader.ReadResult{- .done = false,- .value = .fromChunk(chunk),- };-- if (comptime lp.IS_DEBUG) {- if (exec.js.local == null) {- log.fatal(.bug, "null context scope", .{ .src = "ReadableStreamDefaultController.enqueue", .url = exec.url.* });- std.debug.assert(exec.js.local != null);- }- }-var ls: js.Local.Scope = undefined;- exec.js.localScope(&ls);+ self._execution.js.localScope(&ls);defer ls.deinit();-- ls.toLocal(resolver).resolve("stream enqueue", result);+ return self.enqueueLocal(&ls.local, try chunkToJs(&ls.local, chunk), "stream enqueue");}/// Enqueue a raw JS value, preserving its type (number, bool, object, etc.).@@ -150,32 +120,57 @@ pub fn enqueueValue(self: *ReadableStreamDefaultController, value: js.Value) !voreturn error.StreamNotReadable;}- const exec = self._execution;+ var ls: js.Local.Scope = undefined;+ self._execution.js.localScope(&ls);+ defer ls.deinit();+ return self.enqueueLocal(&ls.local, value, "stream enqueue value");+}++fn enqueueLocal(self: *ReadableStreamDefaultController, local: *const js.Local, value: js.Value, comptime source: []const u8) !void {if (self._pending_reads.items.len == 0) {- const persisted = try value.persist();- try self._queue.append(self._arena, .{ .js_value = persisted });- return;+ return self.queueValue(value);}- const resolver = self._pending_reads.orderedRemove(0);- const persisted = try value.persist();- const result = ReadableStreamDefaultReader.ReadResult{- .done = false,- .value = .{ .js_value = persisted },- };-if (comptime lp.IS_DEBUG) {+ const exec = self._execution;if (exec.js.local == null) {- log.fatal(.bug, "null context scope", .{ .src = "ReadableStreamDefaultController.enqueueValue", .url = exec.url.* });+ log.fatal(.bug, "null context scope", .{ .src = "ReadableStreamDefaultController." ++ source, .url = exec.url.* });std.debug.assert(exec.js.local != null);}}- var ls: js.Local.Scope = undefined;- exec.js.localScope(&ls);- defer ls.deinit();+ // I know, this is ouch! But we expect to have very few (if any)+ // pending reads.+ const resolver = self._pending_reads.orderedRemove(0);+ resolveRead(local, resolver, value, source);+}- ls.toLocal(resolver).resolve("stream enqueue value", result);+fn queueValue(self: *ReadableStreamDefaultController, value: js.Value) !void {+ const persisted = try value.persist();+ errdefer persisted.release();+ try self._queue.append(self._arena, persisted);+}++fn chunkToJs(local: *const js.Local, chunk: Chunk) !js.Value {+ return switch (chunk) {+ inline else => |c| local.zigValueToJs(c, .{}),+ };+}++fn resolveRead(local: *const js.Local, resolver: js.PromiseResolver.Global, value: js.Value, comptime source: []const u8) void {+ defer resolver.release();+ const result = ReadableStreamDefaultReader.ReadResult{+ .done = false,+ .value = .{ .value = value },+ };+ local.toLocal(resolver).resolve(source, result);+}++pub fn clearQueue(self: *ReadableStreamDefaultController) void {+ for (self._queue.items) |chunk| {+ chunk.release();+ }+ self._queue.clearRetainingCapacity();}pub fn close(self: *ReadableStreamDefaultController) !void {@@ -204,6 +199,7 @@ pub fn close(self: *ReadableStreamDefaultController) !void {exec.js.localScope(&ls);defer ls.deinit();ls.toLocal(resolver).resolve("stream close", result);+ resolver.release();}self._pending_reads.clearRetainingCapacity();@@ -226,6 +222,7 @@ fn fail(self: *ReadableStreamDefaultController, err: []const u8, type_error: booself._stream._state = .errored;self._stream._stored_error = try self._arena.dupe(u8, err);+ self.clearQueue();// Reject all pending readsfor (self._pending_reads.items) |resolver| {@@ -235,11 +232,13 @@ fn fail(self: *ReadableStreamDefaultController, err: []const u8, type_error: boo} else {local_resolver.reject("stream error", err);}+ resolver.release();}self._pending_reads.clearRetainingCapacity();}-pub fn dequeue(self: *ReadableStreamDefaultController) ?Chunk {+/// The caller owns the returned global and must release it.+pub fn dequeue(self: *ReadableStreamDefaultController) ?js.Value.Global {if (self._queue.items.len == 0) {return null;}@@ -277,3 +276,53 @@ pub const JsApi = struct {pub const @"error" = bridge.function(ReadableStreamDefaultController.doError, .{});pub const desiredSize = bridge.accessor(ReadableStreamDefaultController.getDesiredSize, null, .{});};++const testing = @import("../../../testing.zig");+test "ReadableStreamDefaultController: chunks and pending reads release their globals" {+ const frame = try testing.createFrame();+ defer testing.test_session.closeAllPages();++ var ls: js.Local.Scope = undefined;+ frame.js.localScope(&ls);+ defer ls.deinit();++ const tracker = &frame.js.page.globals;+ const base = tracker.list.items.len;++ _ = try ls.local.exec(+ \\{+ \\ let c;+ \\ const r = new ReadableStream({ start(ctrl) { c = ctrl; } }).getReader();+ \\ // queued, then read+ \\ for (let i = 0; i < 50; i++) c.enqueue(new Uint8Array(1024));+ \\ for (let i = 0; i < 50; i++) r.read();+ \\ // pending, then enqueued+ \\ for (let i = 0; i < 50; i++) r.read();+ \\ for (let i = 0; i < 50; i++) c.enqueue('x');+ \\ // pending, then closed+ \\ r.read();+ \\ c.close();+ \\}+ \\{+ \\ let c;+ \\ const s = new ReadableStream({ start(ctrl) { c = ctrl; } });+ \\ for (let i = 0; i < 50; i++) c.enqueue(i);+ \\ s.cancel();+ \\}+ \\{+ \\ let c;+ \\ new ReadableStream({ start(ctrl) { c = ctrl; } }).getReader().read();+ \\ c.error('boom');+ \\}+ \\{+ \\ let c;+ \\ new ReadableStream({ start(ctrl) { c = ctrl; } });+ \\ for (let i = 0; i < 50; i++) c.enqueue(i);+ \\ c.error('boom');+ \\}+ \\new Response('native chunk').body.getReader().read();+ , null);++ // cancel() keeps its own resolver so a repeated cancel returns the same promise.+ try testing.expectEqual(base + 1, tracker.list.items.len);+}diff --git a/src/browser/webapi/streams/ReadableStreamDefaultReader.zig b/src/browser/webapi/streams/ReadableStreamDefaultReader.zigindex 87df74dbd..3f2be22c0 100644--- a/src/browser/webapi/streams/ReadableStreamDefaultReader.zig+++ b/src/browser/webapi/streams/ReadableStreamDefaultReader.zig@@ -19,7 +19,6 @@const js = @import("../../js/js.zig");const ReadableStream = @import("ReadableStream.zig");-const ReadableStreamDefaultController = @import("ReadableStreamDefaultController.zig");const Execution = js.Execution;@@ -42,17 +41,7 @@ pub const ReadResult = struct {// Done like this so that we can properly return undefined in some casesconst Chunk = union(enum) {empty,- string: []const u8,- uint8array: js.TypedArray(u8),- js_value: js.Value.Global,-- pub fn fromChunk(chunk: ReadableStreamDefaultController.Chunk) Chunk {- return switch (chunk) {- .string => |s| .{ .string = s },- .uint8array => |arr| .{ .uint8array = arr },- .js_value => |val| .{ .js_value = val },- };- }+ value: js.Value,};};@@ -69,9 +58,10 @@ pub fn read(self: *ReadableStreamDefaultReader, exec: *const Execution) !js.Prom}if (stream._controller.dequeue()) |chunk| {+ defer chunk.release();const result = ReadResult{.done = false,- .value = .fromChunk(chunk),+ .value = .{ .value = local.toLocal(chunk) },};return local.resolvePromise(result);}