Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: document.open resets loaded frame state

Karl Seguinaddaee3d8d90
diff --git a/src/browser/EventManager.zig b/src/browser/EventManager.zig
index 076b6f380..1b114d17d 100644
--- a/src/browser/EventManager.zig
+++ b/src/browser/EventManager.zig
@@ -31,11 +31,12 @@ const ShadowRoot = @import("webapi/ShadowRoot.zig");
const EventTarget = @import("webapi/EventTarget.zig");
const log = lp.log;
+const Allocator = std.mem.Allocator;
+const Listener = EventManagerBase.Listener;
// Re-export types from EventManagerBase for API compatibility
pub const RegisterOptions = EventManagerBase.RegisterOptions;
pub const Callback = EventManagerBase.Callback;
-const Listener = EventManagerBase.Listener;
pub const EventManager = @This();
@@ -89,6 +90,25 @@ pub fn getHandler(self: *EventManager, target: *EventTarget, typ: []const u8) ?j
return self.base.getHandler(frame.js, target, typ);
}
+// Erases the listeners and handlers of the document `root` and its
+// shadow-including descendants (document.open). Detached nodes keep theirs.
+// A connected node belongs to its owner document's tree, so the owner check
+// cheaply skips other documents' nodes before the isConnected walk.
+pub fn removeShadowIncludingDescendants(self: *EventManager, allocator: Allocator, root: *Node) !void {
+ var targets: std.ArrayList(*EventTarget) = .empty;
+ var it = self.base.lookup.keyIterator();
+ while (it.next()) |key| {
+ const target: *EventTarget = @ptrFromInt(key.*);
+ const node = target.is(Node) orelse continue;
+ if (node._owner == root._owner and node.isConnected()) {
+ try targets.append(allocator, target);
+ }
+ }
+ for (targets.items) |target| {
+ self.base.removeTarget(target);
+ }
+}
+
fn noteListener(self: *EventManager, target: *EventTarget, listener: *const Listener) void {
if (target._type == .node and listener.typ.eql(comptime .wrap("load"))) {
// optimization so that we avoid firing load for things (e.g. images)
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index 39c1a6c56..6f8c1e377 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -1393,6 +1393,23 @@ pub fn pendingLoadCompleted(self: *Frame) void {
}
}
+// A document.open() has been closed. If it was opened after it loaded, it
+// will re-trigger DOMContentLoaded and load.
+pub fn scriptCreatedParserDone(self: *Frame) void {
+ switch (self._load_state) {
+ .parsing, .load => {},
+ .waiting => self._load_state = .parsing,
+ .complete => {
+ self._load_state = .parsing;
+ self._parent_notified = false;
+ // the parent was already released the first time, we don't
+ // want documentIsComplete to re-trigger it.
+ self._delays_parent_load = false;
+ },
+ }
+ self.documentIsComplete();
+}
+
pub fn documentIsComplete(self: *Frame) void {
if (self._load_state == .complete) {
// Ideally, documentIsComplete would only be called once, but with
diff --git a/src/browser/tests/document/open_load_events.html b/src/browser/tests/document/open_load_events.html
new file mode 100644
index 000000000..163acb249
--- /dev/null
+++ b/src/browser/tests/document/open_load_events.html
@@ -0,0 +1,84 @@
+<!DOCTYPE html>
+<script src="../testing.js"></script>
+
+<iframe id=loaded src="about:blank"></iframe>
+
+<script id=open_close_fires_load_events type=module>
+ {
+ const state = await testing.async();
+
+ const cw = $('#loaded').contentWindow;
+ const doc = cw.document;
+ const events = [];
+
+ // registered before open(): erased by it
+ cw.addEventListener('load', () => events.push('old window load'));
+ cw.onload = () => events.push('old window onload');
+ doc.addEventListener('DOMContentLoaded', () => events.push('old dcl'));
+ doc.onreadystatechange = () => events.push('old readystatechange');
+
+ // descendants, shadow trees included, lose theirs; detached nodes don't
+ const child = doc.body.appendChild(doc.createElement('div'));
+ child.addEventListener('ping', () => events.push('old child'));
+ const shadowChild = child.attachShadow({ mode: 'open' }).appendChild(doc.createElement('span'));
+ shadowChild.addEventListener('ping', () => events.push('old shadow child'));
+ const detached = doc.createElement('div');
+ detached.addEventListener('ping', () => events.push('detached'));
+
+ // after parsing, so open() clears the document
+ setTimeout(() => {
+ doc.open();
+ testing.expectEqual('loading', doc.readyState);
+
+ child.dispatchEvent(new cw.Event('ping'));
+ shadowChild.dispatchEvent(new cw.Event('ping'));
+ detached.dispatchEvent(new cw.Event('ping'));
+
+ doc.addEventListener('readystatechange', () => events.push('readystatechange ' + doc.readyState));
+ doc.addEventListener('DOMContentLoaded', () => events.push('dcl'));
+ cw.addEventListener('load', () => events.push('window load'));
+
+ doc.write('<p id=written>hello</p>');
+ doc.close();
+
+ setTimeout(() => state.resolve(), 10);
+ }, 5);
+
+ await state.done(() => {
+ testing.expectEqual('hello', doc.getElementById('written').textContent);
+ testing.expectEqual('complete', doc.readyState);
+ testing.expectEqual([
+ 'detached',
+ 'readystatechange interactive',
+ 'dcl',
+ 'readystatechange complete',
+ 'window load',
+ ], events);
+ });
+ }
+</script>
+
+<script id=open_close_on_fresh_iframe type=module>
+ {
+ const state = await testing.async();
+
+ const iframe = document.createElement('iframe');
+ document.body.appendChild(iframe);
+ const cw = iframe.contentWindow;
+ const doc = cw.document;
+ const events = [];
+
+ doc.open();
+ doc.addEventListener('DOMContentLoaded', () => events.push('dcl'));
+ cw.addEventListener('load', () => events.push('window load'));
+ doc.write('<p id=written>fresh</p>');
+ doc.close();
+
+ setTimeout(() => state.resolve(), 10);
+
+ await state.done(() => {
+ testing.expectEqual('fresh', doc.getElementById('written').textContent);
+ testing.expectEqual(['dcl', 'window load'], events);
+ });
+ }
+</script>
diff --git a/src/browser/webapi/Document.zig b/src/browser/webapi/Document.zig
index 0691a763c..4512defa2 100644
--- a/src/browser/webapi/Document.zig
+++ b/src/browser/webapi/Document.zig
@@ -1224,6 +1224,14 @@ pub fn open(self: *Document, call_frame: *Frame) !*Document {
// If we aren't parsing, then open clears the document.
const doc_node = self.asNode();
+ {
+ // Erase all event listeners and handlers of the document
+ try frame._event_manager.removeShadowIncludingDescendants(call_frame.local_arena, doc_node);
+ if (frame.document == self) {
+ frame.page.event_listeners.removeTarget(frame.window.asEventTarget());
+ }
+ }
+
{
// Remove all children from document
var it = doc_node.childrenIterator();
@@ -1299,7 +1307,7 @@ fn finishScriptCreatedParser(self: *Document, frame: *Frame) !void {
// iframe written into via document.write), so we can't rely on it.
frame._script_manager.base.scriptCreatedParseDone();
- frame.documentIsComplete();
+ frame.scriptCreatedParserDone();
}
fn getFirstElementChild(self: *Document) ?*Element {