Lightpanda: the headless browser designed for AI and automation
Move preloads out of async_scripts
Karl Seguind24832ee08d9
diff --git a/src/browser/ScriptManager.zig b/src/browser/ScriptManager.zigindex 298bf317d..96631d005 100644--- a/src/browser/ScriptManager.zig+++ b/src/browser/ScriptManager.zig@@ -61,19 +61,20 @@ pub fn init(allocator: Allocator, http_client: *HttpClient, frame: *Frame) Scrip}pub fn deinit(self: *ScriptManager) void {- self.freeDonePreloads();+ self.freePreloads();self.base.deinit();self.preloaded_scripts.deinit(self.base.allocator);}pub fn reset(self: *ScriptManager) void {- self.freeDonePreloads();+ self.freePreloads();self.preloaded_scripts.clearRetainingCapacity();self.base.reset();self.frame_notified_of_completion = false;}-fn freeDonePreloads(self: *ScriptManager) void {+// Frees every preloaded Script+fn freePreloads(self: *ScriptManager) void {var it = self.preloaded_scripts.valueIterator();while (it.next()) |preload_script| {preload_script.deinit();@@ -107,7 +108,7 @@ pub fn preloadScript(self: *ScriptManager, url: []const u8) !void {}const frame = self.frame;- const arena = try frame.getArena(.medium, "SM.preloadScript");+ const arena = try frame.getArena(.large, "SM.preloadScript");errdefer frame.releaseArena(arena);const owned_url = try arena.dupeZ(u8, url);@@ -123,24 +124,14 @@ pub fn preloadScript(self: *ScriptManager, url: []const u8) !void {.extra = .preload,};- try self.preloaded_scripts.putNoClobber(self.base.allocator, owned_url, .{});+ try self.preloaded_scripts.putNoClobber(self.base.allocator, owned_url, .{ .state = .{ .loading = script } });errdefer _ = self.preloaded_scripts.remove(owned_url);if (comptime IS_DEBUG) {log.debug(.http, "script queue", .{ .url = owned_url, .ctx = "preload" });}- // Tracked in async_scripts only while in flight so shutdown/reset can free a- // never-consumed preload; preloadDoneCallback moves ownership to the map.- self.base.async_scripts.append(&script.node);-- // Guard against a synchronous completion re-entering evaluate() mid-parse,- // the same reason getAsyncImport does.- const was_evaluating = self.base.is_evaluating;- self.base.is_evaluating = true;- defer self.base.is_evaluating = was_evaluating;-- frame.makeRequest(.{+ try frame.makeRequest(.{.ctx = script,.url = owned_url,.method = .GET,@@ -156,10 +147,7 @@ pub fn preloadScript(self: *ScriptManager, url: []const u8) !void {.data_callback = Script.dataCallback,.done_callback = PreloadedScript.doneCallback,.error_callback = PreloadedScript.errorCallback,- }) catch |err| {- self.base.async_scripts.remove(&script.node);- return err;- };+ });}fn waitForPreload(self: *ScriptManager, url: [:0]const u8) ?*Script {@@ -185,7 +173,6 @@ fn waitForPreload(self: *ScriptManager, url: [:0]const u8) ?*Script {_ = self.preloaded_scripts.remove(url);return script;},- .err => return null,}}}@@ -430,18 +417,16 @@ pub fn staticScriptsDone(self: *ScriptManager) void {}const PreloadedScript = struct {- state: State = .loading,+ state: State,const State = union(enum) {- err,- loading,+ loading: *Script,done: *Script,};pub fn deinit(self: PreloadedScript) void {switch (self.state) {- .done => |script| script.deinit(),- else => {},+ inline else => |script| script.deinit(),}}@@ -453,12 +438,7 @@ const PreloadedScript = struct {}const self: *ScriptManager = @fieldParentPtr("base", script.manager);- // Hand ownership to the map; the blocking path adopts the body via- // waitForPreload, and reset() frees the .done entry.- self.base.async_scripts.remove(&script.node);self.preloaded_scripts.getPtr(script.url).?.state = .{ .done = script };-- self.base.evaluate();}fn errorCallback(ctx: *anyopaque, err: anyerror) void {@@ -470,12 +450,7 @@ const PreloadedScript = struct {}const self: *ScriptManager = @fieldParentPtr("base", script.manager);- self.base.async_scripts.remove(&script.node);_ = self.preloaded_scripts.remove(script.url);script.deinit();-- if (self.base.shutdown == false) {- self.base.evaluate();- }}};diff --git a/src/browser/ScriptManagerBase.zig b/src/browser/ScriptManagerBase.zigindex e3cc3b009..f5a672ae5 100644--- a/src/browser/ScriptManagerBase.zig+++ b/src/browser/ScriptManagerBase.zig@@ -650,7 +650,7 @@ pub const Script = struct {entry.state = .{ .done = self };entry.buffer = self.source.remote;},- .preload => unreachable, // preloads use ScriptManager.preloadDoneCallback+ .preload => unreachable, // preloads use ScriptManager.PreloadedScript.doneCallback}manager.evaluate();}@@ -693,7 +693,7 @@ pub const Script = struct {entry.state = .err;},.frame => self.executeCallback(comptime .wrap("error")),- .preload => unreachable, // preloads use ScriptManager.preloadErrorCallback+ .preload => unreachable, // preloads use ScriptManager.PreloadedScript.errorCallback}self.deinit();manager.evaluate();diff --git a/src/browser/tests/element/html/script/preload.html b/src/browser/tests/element/html/script/preload.htmlnew file mode 100644index 000000000..26ea2a291--- /dev/null+++ b/src/browser/tests/element/html/script/preload.html@@ -0,0 +1,38 @@+<!DOCTYPE html>+<script src="../../../testing.js"></script>++<!--+ The preload hint is declared before the <script> that consumes it, so by the+ time the parser blocks on `preload.js` the fetch is already in flight (or+ done). ScriptManager.waitForPreload adopts that body instead of issuing a+ fresh syncRequest, then the consumed entry is freed by the caller. Both halves+ of that ownership handover run under the leak detector here.+-->+<link rel="preload" as="script" href="preload.js">++<!--+ A preload with no matching <script> is fetched but never executed. It lingers+ as a `.done` (or still-loading) entry until reset() frees it — exercises+ freePreloads / map cleanup under the leak detector — and it must not run on+ its own, nor delay the load event.+-->+<link rel="preload" as="script" href="preload_unused.js">++<script id="setup">+ var order = '';+ testing.expectEqual('', order);+</script>++<!-- Blocking remote script: its body is adopted from the preload above. -->+<script id="preloaded" src="preload.js"></script>++<script id="after">+ // The preloaded blocking script executed, in document order, before us.+ order += 'b';+ testing.expectEqual('ab', order);+</script>++<script id="unused_check">+ // A preload hint that nothing consumes must never execute.+ testing.expectEqual(undefined, window.unused_preload_ran);+</script>diff --git a/src/browser/tests/element/html/script/preload.js b/src/browser/tests/element/html/script/preload.jsnew file mode 100644index 000000000..658e1e9f0--- /dev/null+++ b/src/browser/tests/element/html/script/preload.js@@ -0,0 +1,2 @@+order += 'a';+testing.expectEqual('a', order);diff --git a/src/browser/tests/element/html/script/preload_unused.js b/src/browser/tests/element/html/script/preload_unused.jsnew file mode 100644index 000000000..f0d04b8a1--- /dev/null+++ b/src/browser/tests/element/html/script/preload_unused.js@@ -0,0 +1,4 @@+// Nothing consumes this preload, so it must never be evaluated. If it runs, the+// flag trips the assertion in preload.html (and this fail() fires directly).+window.unused_preload_ran = true;+testing.fail('an unconsumed <link rel=preload as=script> must not execute');