Skip to content

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.zig
index 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.zig
index 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.html
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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');