Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

refactor(renderer): make parser finish boundaries explicit

ldm03d6f263e283e
diff --git a/moli-renderer-v8/src/document_runtime.rs b/moli-renderer-v8/src/document_runtime.rs
index e789e7cd0..0d1957ed8 100644
--- a/moli-renderer-v8/src/document_runtime.rs
+++ b/moli-renderer-v8/src/document_runtime.rs
@@ -1,6 +1,7 @@
use std::{
cell::RefCell,
collections::{HashMap, HashSet, VecDeque},
+ rc::Weak,
sync::Arc,
};
@@ -110,6 +111,7 @@ pub(crate) use stylesheet_runtime::{
pub(super) type DomHandle = NativeNodeId;
pub(crate) type ParserStreamHandle = crate::live_document_parser::DocumentParserStreamHandle;
+type ParserStreamWeakHandle = Weak<RefCell<crate::parser::DocumentStream>>;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum HtmlFragmentCustomElementUpgradeTiming {
@@ -169,7 +171,7 @@ pub(crate) enum PostParseOwnerDriverStep {
#[derive(Debug)]
struct ParserConnectedScriptContext {
- insertion_controller: ParserInsertionController,
+ bridge: ParserConnectedScriptBridge,
_input_context: ParserInputContext,
}
@@ -183,53 +185,121 @@ struct CurrentScriptContext {
pub(crate) struct CurrentScriptContextSpec {
pub(crate) handle: Option<DomHandle>,
pub(crate) parser_write_insertion_point_active: bool,
- pub(crate) parser_insertion_controller: Option<ParserInsertionController>,
+ pub(crate) parser_bridge: Option<ParserConnectedScriptBridge>,
}
#[derive(Clone)]
pub(crate) struct ParserInsertionController {
input_session: ParserInputSession,
- parser_stream: ParserStreamHandle,
- parser_control: DocumentParserSessionControlHandle,
+ parser_stream: ParserStreamWeakHandle,
}
impl std::fmt::Debug for ParserInsertionController {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ParserInsertionController")
.field("input_session", &self.input_session)
- .field("session_id", &self.parser_control.session_id())
- .field("run_state", &self.parser_control.run_state())
.finish()
}
}
impl ParserInsertionController {
- #[cfg(test)]
- pub(crate) fn for_stream(stream: ParserStreamHandle) -> Self {
+ fn for_stream(stream: &ParserStreamHandle) -> Self {
let input_session = stream.borrow().script_input_session();
Self {
input_session,
- parser_stream: stream,
+ parser_stream: std::rc::Rc::downgrade(stream),
+ }
+ }
+
+ pub(crate) fn input_session(&self) -> ParserInputSession {
+ self.input_session.clone()
+ }
+
+ pub(crate) fn with_parser_stream<R>(
+ &self,
+ operation: impl FnOnce(&crate::parser::DocumentStream) -> R,
+ ) -> R {
+ let stream = self
+ .parser_stream
+ .upgrade()
+ .expect("synchronous parser insertion permission outlived its parser session");
+ let stream = stream.borrow();
+ operation(&stream)
+ }
+
+ pub(crate) fn with_parser_stream_mut<R>(
+ &self,
+ operation: impl FnOnce(&mut crate::parser::DocumentStream) -> R,
+ ) -> R {
+ let stream = self
+ .parser_stream
+ .upgrade()
+ .expect("synchronous parser insertion permission outlived its parser session");
+ let mut stream = stream.borrow_mut();
+ operation(&mut stream)
+ }
+}
+
+/// The explicit bridge between parser-connected script execution and the
+/// phase-owned parser session.
+///
+/// The insertion controller is deliberately limited to synchronous input
+/// insertion. Pump/suspend/script-nesting transitions are reported through
+/// the separate session control handle so retaining insertion permission can
+/// never itself authorize parser finalization.
+#[derive(Clone)]
+pub(crate) struct ParserConnectedScriptBridge {
+ insertion_controller: ParserInsertionController,
+ parser_control: DocumentParserSessionControlHandle,
+}
+
+impl std::fmt::Debug for ParserConnectedScriptBridge {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.debug_struct("ParserConnectedScriptBridge")
+ .field("insertion_controller", &self.insertion_controller)
+ .field("session_id", &self.parser_control.session_id())
+ .field("run_state", &self.parser_control.run_state())
+ .field(
+ "pump_session_nesting_level",
+ &self.parser_control.pump_session_nesting_level(),
+ )
+ .field(
+ "parser_script_nesting_level",
+ &self.parser_control.parser_script_nesting_level(),
+ )
+ .field(
+ "finish_request_state",
+ &self.parser_control.finish_request_state(),
+ )
+ .finish()
+ }
+}
+
+impl ParserConnectedScriptBridge {
+ #[cfg(test)]
+ pub(crate) fn for_stream(stream: &ParserStreamHandle) -> Self {
+ Self {
+ insertion_controller: ParserInsertionController::for_stream(stream),
parser_control: DocumentParserSessionControlHandle::new(),
}
}
pub(crate) fn for_session(parser: &DocumentParserSession) -> Option<Self> {
- let parser_stream = parser.html_stream_handle()?;
- let input_session = parser_stream.borrow().script_input_session();
+ let stream = parser.html_stream_handle()?;
Some(Self {
- input_session,
- parser_stream,
+ insertion_controller: ParserInsertionController::for_stream(&stream),
parser_control: parser.control_handle(),
})
}
- pub(crate) fn input_session(&self) -> ParserInputSession {
- self.input_session.clone()
+ pub(crate) fn insertion_controller(&self) -> &ParserInsertionController {
+ &self.insertion_controller
}
- pub(crate) fn parser_stream(&self) -> ParserStreamHandle {
- self.parser_stream.clone()
+ pub(crate) fn enter_parser_script_nesting(
+ &self,
+ ) -> crate::live_document_parser::DocumentParserScriptNestingGuard {
+ self.parser_control.enter_parser_script_nesting()
}
pub(crate) fn run_state(&self) -> DocumentParserRunState {
@@ -390,7 +460,7 @@ struct DocumentWriteExternalScriptStart {
#[derive(Debug)]
struct SuspendedDocumentWriteInsertion {
document_handle: DomHandle,
- parser_insertion_controller: ParserInsertionController,
+ parser_bridge: ParserConnectedScriptBridge,
resume_permit: ParserResumePermit,
resume_permit_consumed: bool,
}
@@ -548,6 +618,7 @@ struct ParserReentryState {
pub(crate) struct ParserScriptNestingGuard {
runtime: *mut DocumentRuntime,
+ _parser_session: Option<crate::live_document_parser::DocumentParserScriptNestingGuard>,
}
pub(crate) struct ParserPauseGuard {
@@ -835,6 +906,9 @@ impl DocumentRuntime {
}
pub(crate) fn enter_parser_script_nesting(&mut self) -> ParserScriptNestingGuard {
+ let parser_session = self
+ .current_parser_bridge()
+ .map(|bridge| bridge.enter_parser_script_nesting());
self.parser_reentry.script_nesting_level = self
.parser_reentry
.script_nesting_level
@@ -842,6 +916,7 @@ impl DocumentRuntime {
.expect("parser script nesting level overflow");
ParserScriptNestingGuard {
runtime: self as *mut DocumentRuntime,
+ _parser_session: parser_session,
}
}
diff --git a/moli-renderer-v8/src/document_runtime/document_write.rs b/moli-renderer-v8/src/document_runtime/document_write.rs
index 76722a8fe..c6356396a 100644
--- a/moli-renderer-v8/src/document_runtime/document_write.rs
+++ b/moli-renderer-v8/src/document_runtime/document_write.rs
@@ -369,10 +369,6 @@ impl DocumentRuntime {
.as_ref()
.is_none_or(|parser| parser.lifetime() != DocumentParserLifetime::Closing)
|| self.has_pending_document_write_parser_blocking_work()
- || self
- .root_document_parser
- .as_ref()
- .is_some_and(|parser| parser.run_state() != DocumentParserRunState::Ready)
|| self
.root_document_parser
.as_ref()
@@ -380,16 +376,17 @@ impl DocumentRuntime {
{
return false;
}
- // A speculative script preload can complete before a blocking
- // stylesheet. Resuming that stylesheet may then consume the ready
- // script synchronously while an outer parser pump still owns this
- // stream. EOF is real, but finalization must wait until that recovery
- // stack unwinds and the root controller is again the sole owner.
- if self
+ let parser = self
.root_document_parser
- .as_ref()
- .is_some_and(|parser| !parser.has_exclusive_stream_handle())
- {
+ .as_mut()
+ .expect("closing root parser existence was checked");
+ // This is an actual attempt to end, not merely the earlier close/EOF
+ // notification. If it overlaps a pump, suspension, or parser script,
+ // retain that fact so the next owner boundary must explicitly admit
+ // the delayed finish.
+ parser.request_finish();
+ let _ = parser.admit_delayed_finish_at_local_owner_boundary();
+ if !parser.can_finish_now() {
return false;
}
let Some(mut parser) = self.root_document_parser.take() else {
@@ -1311,12 +1308,14 @@ impl DocumentRuntime {
};
pending
.insertion
- .parser_insertion_controller
+ .parser_bridge
+ .insertion_controller()
.input_session()
.enqueue_script_input_html(html.to_owned());
pending
.insertion
- .parser_insertion_controller
+ .parser_bridge
+ .insertion_controller()
.input_session()
.enqueue_script_input_preload_html(html.to_owned());
true
@@ -1331,12 +1330,14 @@ impl DocumentRuntime {
};
pending
.insertion
- .parser_insertion_controller
+ .parser_bridge
+ .insertion_controller()
.input_session()
.enqueue_script_input_html(html.to_owned());
pending
.insertion
- .parser_insertion_controller
+ .parser_bridge
+ .insertion_controller()
.input_session()
.enqueue_script_input_preload_html(html.to_owned());
true
@@ -1348,12 +1349,14 @@ impl DocumentRuntime {
};
pending
.insertion
- .parser_insertion_controller
+ .parser_bridge
+ .insertion_controller()
.input_session()
.enqueue_script_input_html(html.to_owned());
pending
.insertion
- .parser_insertion_controller
+ .parser_bridge
+ .insertion_controller()
.input_session()
.enqueue_script_input_preload_html(html.to_owned());
true
@@ -1485,11 +1488,11 @@ impl DocumentRuntime {
) -> bool {
match continuation {
SuspendedDocumentWriteContinuation::ResumeAfterCompleted { start, insertion } => {
- let parser_insertion_controller = insertion.parser_insertion_controller.clone();
+ let parser_bridge = insertion.parser_bridge.clone();
self.set_current_script_context(CurrentScriptContextSpec {
handle: Some(start.node),
parser_write_insertion_point_active: true,
- parser_insertion_controller: Some(parser_insertion_controller),
+ parser_bridge: Some(parser_bridge),
});
let changed =
self.resume_suspended_document_write_insertion(scope, host_ptr, insertion);
@@ -1545,14 +1548,17 @@ impl DocumentRuntime {
tracing::debug!(
document_handle = ?insertion.document_handle,
permit = ?insertion.resume_permit,
- run_state = ?insertion.parser_insertion_controller.run_state(),
+ run_state = ?insertion.parser_bridge.run_state(),
"dropping stale document.write parser continuation"
);
return false;
}
let mut changed = false;
- let parser_input_session = insertion.parser_insertion_controller.input_session();
+ let parser_input_session = insertion
+ .parser_bridge
+ .insertion_controller()
+ .input_session();
while let Some(script_input_html) = parser_input_session.take_next_script_input_html() {
if self.write_html_via_parser_stream(
scope,
@@ -1560,7 +1566,7 @@ impl DocumentRuntime {
insertion.document_handle,
&script_input_html,
false,
- &insertion.parser_insertion_controller,
+ &insertion.parser_bridge,
) {
changed = true;
}
@@ -1581,7 +1587,7 @@ impl DocumentRuntime {
insertion.document_handle,
"",
true,
- &insertion.parser_insertion_controller,
+ &insertion.parser_bridge,
) {
changed = true;
}
@@ -1589,10 +1595,9 @@ impl DocumentRuntime {
return true;
}
if !insertion
- .parser_insertion_controller
- .parser_stream()
- .borrow()
- .has_pending_input()
+ .parser_bridge
+ .insertion_controller()
+ .with_parser_stream(DocumentStream::has_pending_input)
{
break;
}
@@ -1605,14 +1610,13 @@ impl DocumentRuntime {
insertion: &mut SuspendedDocumentWriteInsertion,
) -> bool {
if insertion.resume_permit_consumed {
- return insertion.parser_insertion_controller.run_state()
- == DocumentParserRunState::Ready;
+ return insertion.parser_bridge.run_state() == DocumentParserRunState::Ready;
}
- let resumed = match insertion.parser_insertion_controller.run_state() {
+ let resumed = match insertion.parser_bridge.run_state() {
DocumentParserRunState::Ready => false,
- DocumentParserRunState::Suspended { .. } => insertion
- .parser_insertion_controller
- .resume(insertion.resume_permit),
+ DocumentParserRunState::Suspended { .. } => {
+ insertion.parser_bridge.resume(insertion.resume_permit)
+ }
DocumentParserRunState::Pumping { .. }
| DocumentParserRunState::Finishing
| DocumentParserRunState::Finished
@@ -1628,7 +1632,7 @@ impl DocumentRuntime {
insertion: &mut SuspendedDocumentWriteInsertion,
cause: ParserSuspensionCause,
) {
- insertion.resume_permit = insertion.parser_insertion_controller.suspend(cause);
+ insertion.resume_permit = insertion.parser_bridge.suspend(cause);
insertion.resume_permit_consumed = false;
}
@@ -1731,7 +1735,7 @@ impl DocumentRuntime {
tracing::debug!(
target = ?completion_target,
permit = ?insertion.resume_permit,
- run_state = ?insertion.parser_insertion_controller.run_state(),
+ run_state = ?insertion.parser_bridge.run_state(),
"rejecting document.write external-script terminal for a stale parser suspension"
);
return super::DocumentWriteExternalScriptLoadApplication::RejectedStaleTarget;
@@ -1778,7 +1782,7 @@ impl DocumentRuntime {
start.node,
&start.host_script_handle,
source,
- Some(insertion.parser_insertion_controller.clone()),
+ Some(insertion.parser_bridge.clone()),
DocumentWriteCurrentScriptEventBehavior::DispatchImmediately(
ScriptEventKind::Load,
),
@@ -1872,13 +1876,13 @@ impl DocumentRuntime {
fn take_suspended_document_write_insertion(
&mut self,
document_handle: DomHandle,
- parser_insertion_controller: &ParserInsertionController,
+ parser_bridge: &ParserConnectedScriptBridge,
cause: ParserSuspensionCause,
) -> SuspendedDocumentWriteInsertion {
SuspendedDocumentWriteInsertion {
document_handle,
- parser_insertion_controller: parser_insertion_controller.clone(),
- resume_permit: parser_insertion_controller.suspend(cause),
+ parser_bridge: parser_bridge.clone(),
+ resume_permit: parser_bridge.suspend(cause),
resume_permit_consumed: false,
}
}
@@ -1886,7 +1890,7 @@ impl DocumentRuntime {
fn suspend_document_write_stylesheet_blocked_script(
&mut self,
document_handle: DomHandle,
- parser_insertion_controller: &ParserInsertionController,
+ parser_bridge: &ParserConnectedScriptBridge,
node: DomHandle,
start_line: u64,
start_column: u64,
@@ -1902,7 +1906,7 @@ impl DocumentRuntime {
let _ = self.dom_host_mut().set_script_already_started(node, true);
let insertion = self.take_suspended_document_write_insertion(
document_handle,
- parser_insertion_controller,
+ parser_bridge,
ParserSuspensionCause::ParserClassicStylesheets { script: node },
);
self.pending_document_write_stylesheet_blocked_script =
@@ -1921,7 +1925,7 @@ impl DocumentRuntime {
&mut self,
host_ptr: *mut JsContextHost,
document_handle: DomHandle,
- parser_insertion_controller: &ParserInsertionController,
+ parser_bridge: &ParserConnectedScriptBridge,
stylesheet_owner: DomHandle,
blocking_signatures: HashSet<DocumentBlockingStylesheetSignature>,
) -> bool {
@@ -1932,15 +1936,14 @@ impl DocumentRuntime {
);
let insertion = self.take_suspended_document_write_insertion(
document_handle,
- parser_insertion_controller,
+ parser_bridge,
ParserSuspensionCause::ParserCreatedStylesheet {
owner: stylesheet_owner,
},
);
- let preload_html = parser_insertion_controller
- .parser_stream()
- .borrow()
- .snapshot_pending_input();
+ let preload_html = parser_bridge
+ .insertion_controller()
+ .with_parser_stream(DocumentStream::snapshot_pending_input);
self.scan_document_write_script_preloads(host_ptr, &preload_html, true);
self.pending_document_write_stylesheet_parser_pause =
Some(PendingDocumentWriteStylesheetParserPause {
@@ -1955,7 +1958,7 @@ impl DocumentRuntime {
scope: &mut v8::PinScope<'_, '_>,
host_ptr: *mut JsContextHost,
document_handle: DomHandle,
- parser_insertion_controller: &ParserInsertionController,
+ parser_bridge: &ParserConnectedScriptBridge,
node: DomHandle,
start_line: u64,
start_column: u64,
@@ -1970,14 +1973,14 @@ impl DocumentRuntime {
host_ptr,
node,
script,
- Some(parser_insertion_controller.clone()),
+ Some(parser_bridge.clone()),
)
else {
return false;
};
let insertion = self.take_suspended_document_write_insertion(
document_handle,
- parser_insertion_controller,
+ parser_bridge,
ParserSuspensionCause::DocumentWriteExternalScript { script: node },
);
self.start_document_write_external_script_load(
@@ -2051,14 +2054,14 @@ impl DocumentRuntime {
host_ptr,
node,
script,
- Some(insertion.parser_insertion_controller.clone()),
+ Some(insertion.parser_bridge.clone()),
) {
DocumentWriteScriptRunOutcome::Complete => {
- let parser_insertion_controller = insertion.parser_insertion_controller.clone();
+ let parser_bridge = insertion.parser_bridge.clone();
self.set_current_script_context(CurrentScriptContextSpec {
handle: Some(node),
parser_write_insertion_point_active: true,
- parser_insertion_controller: Some(parser_insertion_controller),
+ parser_bridge: Some(parser_bridge),
});
let _ = self.resume_suspended_document_write_insertion(scope, host_ptr, insertion);
self.clear_current_script_handle();
@@ -2087,7 +2090,7 @@ impl DocumentRuntime {
scope: &mut v8::PinScope<'_, '_>,
host_ptr: *mut JsContextHost,
document_handle: DomHandle,
- parser_insertion_controller: &ParserInsertionController,
+ parser_bridge: &ParserConnectedScriptBridge,
node: DomHandle,
start_line: u64,
start_column: u64,
@@ -2100,7 +2103,7 @@ impl DocumentRuntime {
host_ptr,
node,
script,
- Some(parser_insertion_controller.clone()),
+ Some(parser_bridge.clone()),
) {
DocumentWriteScriptRunOutcome::Complete => {
self.has_pending_document_write_parser_blocking_work()
@@ -2110,7 +2113,7 @@ impl DocumentRuntime {
scope,
host_ptr,
document_handle,
- parser_insertion_controller,
+ parser_bridge,
start,
),
}
@@ -2286,13 +2289,13 @@ impl DocumentRuntime {
scope: &mut v8::PinScope<'_, '_>,
host_ptr: *mut JsContextHost,
document_handle: DomHandle,
- parser_insertion_controller: &ParserInsertionController,
+ parser_bridge: &ParserConnectedScriptBridge,
start: Box<DocumentWriteExternalScriptStart>,
) -> bool {
let script = start.node;
let insertion = self.take_suspended_document_write_insertion(
document_handle,
- parser_insertion_controller,
+ parser_bridge,
ParserSuspensionCause::DocumentWriteExternalScript { script },
);
self.start_document_write_external_script_load(
@@ -2309,7 +2312,7 @@ impl DocumentRuntime {
scope: &mut v8::PinScope<'_, '_>,
host_ptr: *mut JsContextHost,
document_handle: DomHandle,
- parser_insertion_controller: &ParserInsertionController,
+ parser_bridge: &ParserConnectedScriptBridge,
handoff: ParserScriptHandoff,
) -> bool {
match handoff {
@@ -2328,7 +2331,7 @@ impl DocumentRuntime {
scope,
host_ptr,
document_handle,
- parser_insertion_controller,
+ parser_bridge,
node_id,
start_line,
start_column,
@@ -2338,7 +2341,7 @@ impl DocumentRuntime {
} else {
self.suspend_document_write_stylesheet_blocked_script(
document_handle,
- parser_insertion_controller,
+ parser_bridge,
node_id,
start_line,
start_column,
@@ -2351,7 +2354,7 @@ impl DocumentRuntime {
scope,
host_ptr,
document_handle,
- parser_insertion_controller,
+ parser_bridge,
node_id,
start_line,
start_column,
@@ -2444,10 +2447,10 @@ impl DocumentRuntime {
document_handle: DomHandle,
html: &str,
resume_existing_insertion: bool,
- parser_insertion_controller: &ParserInsertionController,
+ parser_bridge: &ParserConnectedScriptBridge,
) -> bool {
- let stream = parser_insertion_controller.parser_stream();
- let parser_input_session = parser_insertion_controller.input_session();
+ let insertion_controller = parser_bridge.insertion_controller();
+ let parser_input_session = insertion_controller.input_session();
parser_input_session.enqueue_script_input_preload_html(html.to_owned());
let mut chunk = parser_input_session.take_current_script_input_html();
@@ -2455,12 +2458,17 @@ impl DocumentRuntime {
if chunk.is_empty() && !resume_existing_insertion {
return true;
}
+ // One logical pump session includes processing the tokenizer yield and
+ // any synchronous parser continuation it triggers. In particular, a
+ // cache-hot external script can suspend and resume recursively before
+ // this call returns. Parser finalization must wait for the outermost
+ // pump frame, matching Blink's nested PumpTokenizer session boundary.
+ let _pump_guard = parser_bridge.begin_pump();
let _parser_insertion_session = self.enter_parser_insertion_session();
let mut begin_insertion = !chunk.is_empty();
loop {
let parser_step = {
- let _pump_guard = parser_insertion_controller.begin_pump();
let input = if begin_insertion {
DocumentWriteParserPumpInput::Inserted(chunk.as_str())
} else if resume_existing_insertion && chunk.is_empty() {
@@ -2473,12 +2481,9 @@ impl DocumentRuntime {
} else {
DocumentWriteParserPumpInput::Ordinary(chunk.as_str())
};
- self.pump_document_write_parser_step(
- scope,
- host_ptr,
- &mut stream.borrow_mut(),
- input,
- )
+ insertion_controller.with_parser_stream_mut(|stream| {
+ self.pump_document_write_parser_step(scope, host_ptr, stream, input)
+ })
};
let DocumentWriteParserPumpStep {
outcome:
@@ -2489,9 +2494,10 @@ impl DocumentRuntime {
discovered_blocking_stylesheet_inputs,
},
} = parser_step;
- let discovered_parser_meta_csp_candidates = stream
- .borrow_mut()
- .drain_discovered_parser_meta_csp_candidates();
+ let discovered_parser_meta_csp_candidates = insertion_controller
+ .with_parser_stream_mut(
+ DocumentStream::drain_discovered_parser_meta_csp_candidates,
+ );
for handle in &discovered_parser_meta_csp_candidates {
self.process_parser_meta_content_security_policy(*handle);
}
@@ -2538,7 +2544,7 @@ impl DocumentRuntime {
&& self.suspend_document_write_stylesheet_parser_pause(
host_ptr,
document_handle,
- parser_insertion_controller,
+ parser_bridge,
pause.node_id,
blocking_signatures,
)
@@ -2551,7 +2557,7 @@ impl DocumentRuntime {
scope,
host_ptr,
document_handle,
- parser_insertion_controller,
+ parser_bridge,
*handoff,
) {
return true;
@@ -2651,11 +2657,11 @@ impl DocumentRuntime {
return true;
}
- let parser_insertion_controller = self
+ let parser_bridge = self
.root_document_parser
.as_ref()
- .and_then(ParserInsertionController::for_session)
- .or_else(|| self.current_parser_insertion_controller())
+ .and_then(ParserConnectedScriptBridge::for_session)
+ .or_else(|| self.current_parser_bridge())
.expect("document.write() must have a live root stream or parser insertion controller");
self.write_html_via_parser_stream(
scope,
@@ -2663,7 +2669,7 @@ impl DocumentRuntime {
document_handle,
html,
false,
- &parser_insertion_controller,
+ &parser_bridge,
)
}
}
@@ -2755,7 +2761,11 @@ mod tests {
.as_ref()
.expect("root replacement parser session");
assert_eq!(parser.lifetime(), DocumentParserLifetime::Open);
- assert!(parser.has_exclusive_stream_handle());
+ assert_eq!(parser.run_state(), DocumentParserRunState::Ready);
+ assert_eq!(
+ parser.finish_request_state(),
+ crate::live_document_parser::DocumentParserFinishRequestState::NotRequested
+ );
}
#[test]
diff --git a/moli-renderer-v8/src/document_runtime/lifecycle.rs b/moli-renderer-v8/src/document_runtime/lifecycle.rs
index 8173c287e..7b1177b30 100644
--- a/moli-renderer-v8/src/document_runtime/lifecycle.rs
+++ b/moli-renderer-v8/src/document_runtime/lifecycle.rs
@@ -435,23 +435,26 @@ impl DocumentRuntime {
let CurrentScriptContextSpec {
handle,
parser_write_insertion_point_active,
- parser_insertion_controller,
+ parser_bridge,
} = spec;
let handle = handle.filter(|node| self.dom_host.node(*node).is_some());
- let parser_insertion_controller = parser_insertion_controller
+ let parser_bridge = parser_bridge
.or_else(|| {
self.current_script_context().and_then(|context| {
context
.parser_connected
.as_ref()
- .map(|parser| parser.insertion_controller.clone())
+ .map(|parser| parser.bridge.clone())
})
})
.filter(|_| parser_write_insertion_point_active);
- let parser_connected = parser_insertion_controller.map(|insertion_controller| {
- let input_context = insertion_controller.input_session().enter_pending_context();
+ let parser_connected = parser_bridge.map(|bridge| {
+ let input_context = bridge
+ .insertion_controller()
+ .input_session()
+ .enter_pending_context();
ParserConnectedScriptContext {
- insertion_controller,
+ bridge,
_input_context: input_context,
}
});
@@ -474,10 +477,10 @@ impl DocumentRuntime {
.is_some_and(|context| context.parser_connected.is_some())
}
- pub(super) fn current_parser_insertion_controller(&self) -> Option<ParserInsertionController> {
+ pub(super) fn current_parser_bridge(&self) -> Option<ParserConnectedScriptBridge> {
self.current_script_context()
.and_then(|context| context.parser_connected.as_ref())
- .map(|context| context.insertion_controller.clone())
+ .map(|context| context.bridge.clone())
}
pub(crate) fn take_post_parse_schedule_invalidated(&mut self) -> bool {
@@ -581,7 +584,7 @@ mod tests {
};
use super::{
- CurrentScriptContextSpec, DocumentRuntime, DomHandle, ParserInsertionController,
+ CurrentScriptContextSpec, DocumentRuntime, DomHandle, ParserConnectedScriptBridge,
PostParsePageTaskPopBlocker,
};
@@ -632,12 +635,12 @@ mod tests {
runtime.set_current_script_context(CurrentScriptContextSpec {
handle: None,
parser_write_insertion_point_active: true,
- parser_insertion_controller: Some(ParserInsertionController::for_stream(stream)),
+ parser_bridge: Some(ParserConnectedScriptBridge::for_stream(&stream)),
});
assert_eq!(runtime.current_script_handle(), None);
assert!(runtime.has_active_parser_write_insertion_point());
- assert!(runtime.current_parser_insertion_controller().is_some());
+ assert!(runtime.current_parser_bridge().is_some());
}
fn modulepreload_as_matrix_markup(base_href: &str) -> String {
diff --git a/moli-renderer-v8/src/document_runtime/script_scheduling/document_write_scripts.rs b/moli-renderer-v8/src/document_runtime/script_scheduling/document_write_scripts.rs
index 88d063b03..22df7442a 100644
--- a/moli-renderer-v8/src/document_runtime/script_scheduling/document_write_scripts.rs
+++ b/moli-renderer-v8/src/document_runtime/script_scheduling/document_write_scripts.rs
@@ -30,7 +30,7 @@ impl DocumentRuntime {
host_ptr: *mut JsContextHost,
node: DomHandle,
mut script: PreparedScript,
- parser_insertion_controller: Option<ParserInsertionController>,
+ parser_bridge: Option<ParserConnectedScriptBridge>,
) -> DocumentWriteScriptRunOutcome {
if !self
.dom_host
@@ -110,7 +110,7 @@ impl DocumentRuntime {
node,
&host_script_handle,
source,
- parser_insertion_controller,
+ parser_bridge,
DocumentWriteCurrentScriptEventBehavior::Skip,
);
DocumentWriteScriptRunOutcome::Complete
@@ -121,7 +121,7 @@ impl DocumentRuntime {
node,
&host_script_handle,
script,
- parser_insertion_controller,
+ parser_bridge,
)
}
}
@@ -133,13 +133,13 @@ impl DocumentRuntime {
node: DomHandle,
host_script_handle: &str,
source: String,
- parser_insertion_controller: Option<ParserInsertionController>,
+ parser_bridge: Option<ParserConnectedScriptBridge>,
current_script_event_behavior: DocumentWriteCurrentScriptEventBehavior,
) {
self.set_current_script_context(CurrentScriptContextSpec {
handle: Some(node),
parser_write_insertion_point_active: true,
- parser_insertion_controller,
+ parser_bridge,
});
// A parser-created script belongs to the document's main world even
// when an isolated/utility world called document.write(). Blink's
@@ -211,7 +211,7 @@ impl DocumentRuntime {
node: DomHandle,
host_script_handle: &str,
script: PreparedScript,
- parser_insertion_controller: Option<ParserInsertionController>,
+ parser_bridge: Option<ParserConnectedScriptBridge>,
) -> DocumentWriteScriptRunOutcome {
if script.kind == ScriptKind::ImportMap
&& script.source_kind == crate::ScriptSourceKind::Inline
@@ -288,7 +288,7 @@ impl DocumentRuntime {
node,
host_script_handle,
source,
- parser_insertion_controller,
+ parser_bridge,
DocumentWriteCurrentScriptEventBehavior::DispatchImmediately(ScriptEventKind::Load),
);
DocumentWriteScriptRunOutcome::Complete
diff --git a/moli-renderer-v8/src/live_document_parser.rs b/moli-renderer-v8/src/live_document_parser.rs
index 1160c660d..865c2708e 100644
--- a/moli-renderer-v8/src/live_document_parser.rs
+++ b/moli-renderer-v8/src/live_document_parser.rs
@@ -225,7 +225,7 @@ pub(crate) enum ParserStopReason {
pub(crate) enum DocumentParserRunState {
Ready,
Pumping {
- epoch: u64,
+ nesting_level: usize,
},
Suspended {
id: ParserSuspensionId,
@@ -236,7 +236,42 @@ pub(crate) enum DocumentParserRunState {
Stopped(ParserStopReason),
}
-impl From<ParserSuspension> for DocumentParserRunState {
+/// Tracks a live parser's end request separately from its current execution
+/// state.
+///
+/// `DocumentParserRunState` is the public projection used by callers; pump
+/// nesting is recorded independently so a suspended nested pump can retain
+/// both facts. This state answers whether EOF has requested finalization and
+/// whether the owning parser's safe boundary has admitted a previously delayed
+/// finish.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub(crate) enum DocumentParserFinishRequestState {
+ /// The parser owner can still append ordinary outer input.
+ #[default]
+ NotRequested,
+ /// EOF/close was requested and no unsafe end attempt has been observed.
+ Requested,
+ /// The request overlapped a pump, suspension, or parser-script scope and
+ /// must cross the parser owner's next stable boundary before finalizing.
+ Delayed,
+ /// The stable owner boundary admitted this delayed finish exactly once.
+ /// Entering more parser work consumes the admission.
+ Admitted,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum DocumentParserLifecycleState {
+ Ready,
+ Suspended {
+ id: ParserSuspensionId,
+ cause: ParserSuspensionCause,
+ },
+ Finishing,
+ Finished,
+ Stopped(ParserStopReason),
+}
+
+impl From<ParserSuspension> for DocumentParserLifecycleState {
fn from(suspension: ParserSuspension) -> Self {
Self::Suspended {
id: suspension.id,
@@ -245,21 +280,34 @@ impl From<ParserSuspension> for DocumentParserRunState {
}
}
-impl DocumentParserRunState {
+impl DocumentParserLifecycleState {
fn suspension(self) -> Option<ParserSuspension> {
match self {
Self::Suspended { id, cause } => Some(ParserSuspension { id, cause }),
_ => None,
}
}
+
+ fn observed_run_state(self, pump_session_nesting_level: usize) -> DocumentParserRunState {
+ match (self, pump_session_nesting_level) {
+ (Self::Ready, nesting_level @ 1..) => DocumentParserRunState::Pumping { nesting_level },
+ (Self::Ready, 0) => DocumentParserRunState::Ready,
+ (Self::Suspended { id, cause }, _) => DocumentParserRunState::Suspended { id, cause },
+ (Self::Finishing, _) => DocumentParserRunState::Finishing,
+ (Self::Finished, _) => DocumentParserRunState::Finished,
+ (Self::Stopped(reason), _) => DocumentParserRunState::Stopped(reason),
+ }
+ }
}
#[derive(Debug)]
struct DocumentParserSessionControl {
session_id: ParserSessionId,
next_suspension_id: u64,
- next_pump_epoch: u64,
- run_state: DocumentParserRunState,
+ pump_session_nesting_level: usize,
+ lifecycle_state: DocumentParserLifecycleState,
+ parser_script_nesting_level: usize,
+ finish_request_state: DocumentParserFinishRequestState,
}
#[derive(Clone, Debug)]
@@ -272,8 +320,10 @@ impl DocumentParserSessionControlHandle {
Self(Rc::new(RefCell::new(DocumentParserSessionControl {
session_id,
next_suspension_id: 1,
- next_pump_epoch: 1,
- run_state: DocumentParserRunState::Ready,
+ pump_session_nesting_level: 0,
+ lifecycle_state: DocumentParserLifecycleState::Ready,
+ parser_script_nesting_level: 0,
+ finish_request_state: DocumentParserFinishRequestState::NotRequested,
})))
}
@@ -282,15 +332,89 @@ impl DocumentParserSessionControlHandle {
}
pub(crate) fn run_state(&self) -> DocumentParserRunState {
- self.0.borrow().run_state
+ let control = self.0.borrow();
+ control
+ .lifecycle_state
+ .observed_run_state(control.pump_session_nesting_level)
+ }
+
+ pub(crate) fn parser_script_nesting_level(&self) -> usize {
+ self.0.borrow().parser_script_nesting_level
+ }
+
+ pub(crate) fn pump_session_nesting_level(&self) -> usize {
+ self.0.borrow().pump_session_nesting_level
+ }
+
+ pub(crate) fn finish_request_state(&self) -> DocumentParserFinishRequestState {
+ self.0.borrow().finish_request_state
+ }
+
+ pub(crate) fn enter_parser_script_nesting(&self) -> DocumentParserScriptNestingGuard {
+ let mut control = self.0.borrow_mut();
+ assert!(
+ !matches!(
+ control.lifecycle_state,
+ DocumentParserLifecycleState::Finishing
+ | DocumentParserLifecycleState::Finished
+ | DocumentParserLifecycleState::Stopped(_)
+ ),
+ "a terminal live parser cannot enter parser-script execution"
+ );
+ control.parser_script_nesting_level = control
+ .parser_script_nesting_level
+ .checked_add(1)
+ .expect("live parser script nesting level overflow");
+ if control.finish_request_state == DocumentParserFinishRequestState::Admitted {
+ // Admission authorizes the delayed finish at one exact boundary;
+ // entering more parser-connected work consumes that authority.
+ control.finish_request_state = DocumentParserFinishRequestState::Requested;
+ }
+ drop(control);
+ DocumentParserScriptNestingGuard {
+ control: self.clone(),
+ }
+ }
+
+ fn request_finish(&self) {
+ let mut control = self.0.borrow_mut();
+ let finish_is_unsafe = control.pump_session_nesting_level > 0
+ || matches!(
+ control.lifecycle_state,
+ DocumentParserLifecycleState::Suspended { .. }
+ )
+ || control.parser_script_nesting_level > 0;
+ match (control.finish_request_state, finish_is_unsafe) {
+ (DocumentParserFinishRequestState::Delayed, _) => {}
+ (_, true) => {
+ control.finish_request_state = DocumentParserFinishRequestState::Delayed;
+ }
+ (DocumentParserFinishRequestState::NotRequested, false) => {
+ control.finish_request_state = DocumentParserFinishRequestState::Requested;
+ }
+ (
+ DocumentParserFinishRequestState::Requested
+ | DocumentParserFinishRequestState::Admitted,
+ false,
+ ) => {}
+ }
+ }
+
+ fn admit_delayed_finish(&self) -> bool {
+ let mut control = self.0.borrow_mut();
+ if control.finish_request_state != DocumentParserFinishRequestState::Delayed {
+ return false;
+ }
+ control.finish_request_state = DocumentParserFinishRequestState::Admitted;
+ true
}
pub(crate) fn suspend(&self, cause: ParserSuspensionCause) -> ParserResumePermit {
let mut control = self.0.borrow_mut();
assert_eq!(
- control.run_state,
- DocumentParserRunState::Ready,
- "only a ready live parser session can enter a persistent suspension"
+ control.lifecycle_state,
+ DocumentParserLifecycleState::Ready,
+ "only a live parser without an existing suspension can enter a persistent suspension"
);
let suspension_id = ParserSuspensionId(control.next_suspension_id);
control.next_suspension_id = control
@@ -301,7 +425,14 @@ impl DocumentParserSessionControlHandle {
id: suspension_id,
cause,
};
- control.run_state = suspension.into();
+ if matches!(
+ control.finish_request_state,
+ DocumentParserFinishRequestState::Requested
+ | DocumentParserFinishRequestState::Admitted
+ ) {
+ control.finish_request_state = DocumentParserFinishRequestState::Delayed;
+ }
+ control.lifecycle_state = suspension.into();
ParserResumePermit {
session_id: control.session_id,
suspension_id,
@@ -310,7 +441,7 @@ impl DocumentParserSessionControlHandle {
pub(crate) fn current_resume_permit(&self) -> Option<ParserResumePermit> {
let control = self.0.borrow();
- let suspension = control.run_state.suspension()?;
+ let suspension = control.lifecycle_state.suspension()?;
Some(ParserResumePermit {
session_id: control.session_id,
suspension_id: suspension.id,
@@ -322,75 +453,115 @@ impl DocumentParserSessionControlHandle {
if permit.session_id != control.session_id {
return false;
}
- let Some(suspension) = control.run_state.suspension() else {
+ let Some(suspension) = control.lifecycle_state.suspension() else {
return false;
};
if suspension.id != permit.suspension_id {
return false;
}
- control.run_state = DocumentParserRunState::Ready;
+ control.lifecycle_state = DocumentParserLifecycleState::Ready;
true
}
pub(crate) fn begin_pump(&self) -> DocumentParserPumpGuard {
let mut control = self.0.borrow_mut();
assert_eq!(
- control.run_state,
- DocumentParserRunState::Ready,
- "a live parser may only pump from the ready state"
+ control.lifecycle_state,
+ DocumentParserLifecycleState::Ready,
+ "a suspended or terminal live parser cannot enter a pump session"
);
- let epoch = control.next_pump_epoch;
- control.next_pump_epoch = control.next_pump_epoch.wrapping_add(1).max(1);
- control.run_state = DocumentParserRunState::Pumping { epoch };
+ control.pump_session_nesting_level = control
+ .pump_session_nesting_level
+ .checked_add(1)
+ .expect("live parser pump session nesting level overflow");
+ let nesting_level = control.pump_session_nesting_level;
+ if control.finish_request_state == DocumentParserFinishRequestState::Admitted {
+ // A continuation admission is a one-shot finish authority, not a
+ // blanket permit for arbitrary subsequent parser work.
+ control.finish_request_state = DocumentParserFinishRequestState::Requested;
+ }
drop(control);
DocumentParserPumpGuard {
control: self.clone(),
- epoch,
+ nesting_level,
}
}
fn begin_finish(&self) {
let mut control = self.0.borrow_mut();
assert_eq!(
- control.run_state,
- DocumentParserRunState::Ready,
+ control.lifecycle_state,
+ DocumentParserLifecycleState::Ready,
"a suspended or stopped live parser cannot finish"
);
- control.run_state = DocumentParserRunState::Finishing;
+ assert!(
+ control.pump_session_nesting_level == 0,
+ "a live parser cannot finish inside an active pump session"
+ );
+ assert_eq!(
+ control.parser_script_nesting_level, 0,
+ "a live parser cannot finish while a parser-connected script is executing"
+ );
+ assert!(
+ matches!(
+ control.finish_request_state,
+ DocumentParserFinishRequestState::Requested
+ | DocumentParserFinishRequestState::Admitted
+ ),
+ "parser finish requires an undelayed finish request"
+ );
+ control.lifecycle_state = DocumentParserLifecycleState::Finishing;
}
fn finish(&self) {
let mut control = self.0.borrow_mut();
assert_eq!(
- control.run_state,
- DocumentParserRunState::Finishing,
+ control.lifecycle_state,
+ DocumentParserLifecycleState::Finishing,
"parser finish must complete the active finishing transition"
);
- control.run_state = DocumentParserRunState::Finished;
+ control.lifecycle_state = DocumentParserLifecycleState::Finished;
}
pub(crate) fn stop(&self, reason: ParserStopReason) {
let mut control = self.0.borrow_mut();
if !matches!(
- control.run_state,
- DocumentParserRunState::Finished | DocumentParserRunState::Stopped(_)
+ control.lifecycle_state,
+ DocumentParserLifecycleState::Finished | DocumentParserLifecycleState::Stopped(_)
) {
- control.run_state = DocumentParserRunState::Stopped(reason);
+ control.lifecycle_state = DocumentParserLifecycleState::Stopped(reason);
}
}
}
pub(crate) struct DocumentParserPumpGuard {
control: DocumentParserSessionControlHandle,
- epoch: u64,
+ nesting_level: usize,
+}
+
+pub(crate) struct DocumentParserScriptNestingGuard {
+ control: DocumentParserSessionControlHandle,
+}
+
+impl Drop for DocumentParserScriptNestingGuard {
+ fn drop(&mut self) {
+ let mut control = self.control.0.borrow_mut();
+ assert!(
+ control.parser_script_nesting_level > 0,
+ "parser script nesting guard exited without matching enter"
+ );
+ control.parser_script_nesting_level -= 1;
+ }
}
impl Drop for DocumentParserPumpGuard {
fn drop(&mut self) {
let mut control = self.control.0.borrow_mut();
- if control.run_state == (DocumentParserRunState::Pumping { epoch: self.epoch }) {
- control.run_state = DocumentParserRunState::Ready;
- }
+ assert_eq!(
+ control.pump_session_nesting_level, self.nesting_level,
+ "live parser pump sessions must unwind in stack order"
+ );
+ control.pump_session_nesting_level -= 1;
}
}
@@ -434,6 +605,15 @@ impl std::fmt::Debug for DocumentParserSession {
.field("lifetime", &self.lifetime)
.field("session_id", &self.control.session_id())
.field("run_state", &self.control.run_state())
+ .field(
+ "pump_session_nesting_level",
+ &self.control.pump_session_nesting_level(),
+ )
+ .field(
+ "parser_script_nesting_level",
+ &self.control.parser_script_nesting_level(),
+ )
+ .field("finish_request_state", &self.control.finish_request_state())
.finish_non_exhaustive()
}
}
@@ -571,6 +751,20 @@ impl DocumentParserSession {
self.control.run_state()
}
+ pub(crate) fn finish_request_state(&self) -> DocumentParserFinishRequestState {
+ self.control.finish_request_state()
+ }
+
+ pub(crate) fn can_finish_now(&self) -> bool {
+ self.run_state() == DocumentParserRunState::Ready
+ && self.control.parser_script_nesting_level() == 0
+ && matches!(
+ self.finish_request_state(),
+ DocumentParserFinishRequestState::Requested
+ | DocumentParserFinishRequestState::Admitted
+ )
+ }
+
pub(crate) fn control_handle(&self) -> DocumentParserSessionControlHandle {
self.control.clone()
}
@@ -609,7 +803,10 @@ impl DocumentParserSession {
pub(crate) fn request_close(&mut self) -> DocumentParserCloseDisposition {
self.lifetime = DocumentParserLifetime::Closing;
- if self.run_state() == DocumentParserRunState::Ready {
+ self.control.request_finish();
+ if self.run_state() == DocumentParserRunState::Ready
+ && self.control.parser_script_nesting_level() == 0
+ {
DocumentParserCloseDisposition::DrainNow
} else {
DocumentParserCloseDisposition::DeferredUntilReady
@@ -628,14 +825,29 @@ impl DocumentParserSession {
}
pub(crate) fn suspension_cause(&self) -> Option<ParserSuspensionCause> {
- self.run_state().suspension().map(|pause| pause.cause)
+ match self.run_state() {
+ DocumentParserRunState::Suspended { cause, .. } => Some(cause),
+ _ => None,
+ }
}
- pub(crate) fn has_exclusive_stream_handle(&self) -> bool {
- match self.backend() {
- ExecutableDocumentParserBackend::Html(stream) => Rc::strong_count(stream) == 1,
- ExecutableDocumentParserBackend::Xml(stream) => Rc::strong_count(stream) == 1,
+ /// Record that no more ordinary outer input will arrive. Whether this can
+ /// finish synchronously is decided later, after parser input is drained.
+ pub(crate) fn request_finish(&mut self) {
+ self.control.request_finish();
+ }
+
+ pub(crate) fn admit_delayed_finish_continuation(&mut self) -> bool {
+ self.control.admit_delayed_finish()
+ }
+
+ pub(crate) fn admit_delayed_finish_at_local_owner_boundary(&mut self) -> bool {
+ if self.run_state() != DocumentParserRunState::Ready
+ || self.control.parser_script_nesting_level() > 0
+ {
+ return false;
}
+ self.control.admit_delayed_finish()
}
pub(crate) fn note_defined_autonomous_custom_elements(
@@ -1067,4 +1279,159 @@ mod session_state_tests {
DocumentParserRunState::Stopped(ParserStopReason::OwnerDropped)
);
}
+
+ #[test]
+ fn nested_pump_and_suspension_keep_finish_delayed_until_outermost_boundary() {
+ let mut parser = session();
+ let control = parser.control_handle();
+ parser.request_finish();
+
+ let outer_pump = control.begin_pump();
+ let outer_pump_state = control.run_state();
+ assert_eq!(control.pump_session_nesting_level(), 1);
+ parser.request_finish();
+ assert_eq!(
+ parser.finish_request_state(),
+ DocumentParserFinishRequestState::Delayed
+ );
+
+ let permit = parser.suspend(ParserSuspensionCause::ParserCreatedStylesheet {
+ owner: NativeNodeId::new(2),
+ });
+ assert!(matches!(
+ parser.run_state(),
+ DocumentParserRunState::Suspended { .. }
+ ));
+ assert_eq!(
+ control.pump_session_nesting_level(),
+ 1,
+ "persistent suspension must not erase the resident outer pump frame"
+ );
+ assert!(parser.resume(permit));
+ assert_eq!(
+ parser.run_state(),
+ outer_pump_state,
+ "resuming a nested blocker must reveal the still-active outer pump"
+ );
+
+ {
+ let _nested_pump = control.begin_pump();
+ assert_eq!(control.pump_session_nesting_level(), 2);
+ assert_ne!(parser.run_state(), outer_pump_state);
+ assert!(!parser.admit_delayed_finish_at_local_owner_boundary());
+ }
+ assert_eq!(control.pump_session_nesting_level(), 1);
+ assert_eq!(parser.run_state(), outer_pump_state);
+ drop(outer_pump);
+
+ assert_eq!(control.pump_session_nesting_level(), 0);
+ assert_eq!(parser.run_state(), DocumentParserRunState::Ready);
+ assert!(parser.admit_delayed_finish_at_local_owner_boundary());
+ assert!(parser.can_finish_now());
+ }
+
+ #[test]
+ fn phase_one_finish_is_delayed_until_exact_continuation_admission() {
+ let mut parser = session();
+ let control = parser.control_handle();
+
+ {
+ let _pump = control.begin_pump();
+ parser.request_finish();
+ }
+ assert_eq!(
+ parser.finish_request_state(),
+ DocumentParserFinishRequestState::Delayed
+ );
+ assert!(
+ !parser.can_finish_now(),
+ "recording EOF must not grant parser destruction authority"
+ );
+
+ assert!(parser.admit_delayed_finish_continuation());
+ assert_eq!(
+ parser.finish_request_state(),
+ DocumentParserFinishRequestState::Admitted
+ );
+ assert!(parser.can_finish_now());
+ assert!(
+ !parser.admit_delayed_finish_continuation(),
+ "one selected continuation can only admit the delayed finish once"
+ );
+ }
+
+ #[test]
+ fn parser_script_nesting_blocks_a_requested_finish() {
+ let mut parser = DocumentParserSession::start_open_live_document(
+ Url::parse("https://parser-session.test/").expect("test URL"),
+ NativeNodeId::new(1),
+ );
+ let control = parser.control_handle();
+ let nesting = control.enter_parser_script_nesting();
+
+ assert_eq!(
+ parser.request_close(),
+ DocumentParserCloseDisposition::DeferredUntilReady
+ );
+
+ assert_eq!(control.parser_script_nesting_level(), 1);
+ assert_eq!(
+ parser.finish_request_state(),
+ DocumentParserFinishRequestState::Delayed
+ );
+ assert!(!parser.can_finish_now());
+
+ drop(nesting);
+ assert_eq!(control.parser_script_nesting_level(), 0);
+ assert!(
+ !parser.can_finish_now(),
+ "leaving script execution must not silently erase the delayed-end fact"
+ );
+ assert!(parser.admit_delayed_finish_at_local_owner_boundary());
+ assert!(parser.can_finish_now());
+ }
+
+ #[test]
+ fn completed_parser_script_does_not_delay_a_preexisting_finish_request() {
+ let mut parser = session();
+ let control = parser.control_handle();
+
+ parser.request_finish();
+ let nesting = control.enter_parser_script_nesting();
+ assert!(!parser.can_finish_now());
+ drop(nesting);
+
+ assert_eq!(
+ parser.finish_request_state(),
+ DocumentParserFinishRequestState::Requested
+ );
+ assert!(parser.can_finish_now());
+ }
+
+ #[test]
+ fn new_parser_work_consumes_delayed_finish_admission() {
+ let mut parser = session();
+ let control = parser.control_handle();
+ let nesting = control.enter_parser_script_nesting();
+ parser.request_finish();
+ drop(nesting);
+ assert!(parser.admit_delayed_finish_continuation());
+
+ {
+ let _pump = control.begin_pump();
+ assert_eq!(
+ parser.finish_request_state(),
+ DocumentParserFinishRequestState::Requested
+ );
+ }
+ let permit = parser.suspend(ParserSuspensionCause::ParserCreatedStylesheet {
+ owner: NativeNodeId::new(2),
+ });
+ assert_eq!(
+ parser.finish_request_state(),
+ DocumentParserFinishRequestState::Delayed
+ );
+ assert!(parser.resume(permit));
+ assert!(!parser.can_finish_now());
+ }
}
diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_documents/live_parser.rs b/moli-renderer-v8/src/native_bridge/context_host/child_documents/live_parser.rs
index 9708da138..eebb70f7a 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/child_documents/live_parser.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/child_documents/live_parser.rs
@@ -883,6 +883,8 @@ impl JsContextHost {
document_handle: DomHandle,
mut parser: DocumentParserSession,
) -> Option<crate::frame_owner_model::FrameDocumentInteractiveLifecycleAction> {
+ parser.request_finish();
+ let _ = parser.admit_delayed_finish_at_local_owner_boundary();
let finish_signals = {
let mut owner = ChildFrameLiveParserOwner::new(self, scope, document_handle);
parser.finish(&mut owner)
diff --git a/moli-renderer-v8/src/runtime/phase_one/bootstrap.rs b/moli-renderer-v8/src/runtime/phase_one/bootstrap.rs
index c1d166b90..8ee733368 100644
--- a/moli-renderer-v8/src/runtime/phase_one/bootstrap.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/bootstrap.rs
@@ -106,7 +106,7 @@ impl ConcurrentParseTimeRuntime {
service_worker_preload_context.as_ref(),
);
state.parser_session.queue_arrived_chunk(html);
- state.input_closed = true;
+ state.close_input();
let (state, page_vm, triggered_navigation) =
Self::bootstrap_page_vm_from_state_on_fresh_local_task(
page_id,
@@ -189,7 +189,7 @@ impl ConcurrentParseTimeRuntime {
);
state.parser_session.queue_arrived_chunk(source);
state.parser_session.declare_eof();
- state.input_closed = true;
+ state.close_input();
let (state, page_vm, triggered_navigation) =
Self::bootstrap_page_vm_from_state_on_fresh_local_task(
page_id,
diff --git a/moli-renderer-v8/src/runtime/phase_one/mod.rs b/moli-renderer-v8/src/runtime/phase_one/mod.rs
index 523e5b4b8..120f6a647 100644
--- a/moli-renderer-v8/src/runtime/phase_one/mod.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/mod.rs
@@ -3871,14 +3871,14 @@ document.body.setAttribute('data-error-state', [
}
#[test]
- fn main_parser_finish_waits_for_transient_insertion_controller() {
+ fn main_parser_finish_waits_for_phase_one_continuation_boundary() {
run_phase_one_large_stack_test(
- "phase-one-main-parser-finish-after-insertion-controller",
- main_parser_finish_waits_for_transient_insertion_controller_inner,
+ "phase-one-main-parser-finish-after-continuation-boundary",
+ main_parser_finish_waits_for_phase_one_continuation_boundary_inner,
);
}
- fn main_parser_finish_waits_for_transient_insertion_controller_inner() {
+ fn main_parser_finish_waits_for_phase_one_continuation_boundary_inner() {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
@@ -3891,12 +3891,22 @@ document.body.setAttribute('data-error-state', [
ResourceRequestClient::new(&FetchConfig::default()).expect("default loader");
let loader = loader_owner.clone();
let mut state = ParseTimeDriverState::new(final_url);
- state.input_closed = true;
- let insertion_controller =
- crate::document_runtime::ParserInsertionController::for_session(
+ state.close_input();
+ let parser_bridge =
+ crate::document_runtime::ParserConnectedScriptBridge::for_session(
&state.parser_session,
)
- .expect("HTML parser should expose an insertion controller");
+ .expect("HTML parser should expose a parser-connected script bridge");
+ let resume_permit = parser_bridge.suspend(
+ crate::live_document_parser::ParserSuspensionCause::ParserCreatedStylesheet {
+ owner: crate::dom::native::NativeNodeId::new(1),
+ },
+ );
+ assert_eq!(
+ state.parser_session.finish_request_state(),
+ crate::live_document_parser::DocumentParserFinishRequestState::Delayed
+ );
+ assert!(parser_bridge.resume(resume_permit));
let parser_dom_host = state
.parser_session
.stream_handle()
@@ -3923,13 +3933,18 @@ document.body.setAttribute('data-error-state', [
let completion = ParseTimePhaseOnePump::new(phase_runtime)
.run_to_completion()
.await
- .expect("borrowed parser stream should park instead of finishing");
+ .expect("EOF should park instead of finishing in the requesting turn");
let super::loop_protocol::ParseTimeOwnerCompletion::PendingPageTask(
mut phase_runtime,
) = completion
else {
- panic!("borrowed parser stream should publish one continuation task");
+ panic!("EOF should publish one phase-one continuation task");
};
+ assert_eq!(
+ phase_runtime.state.parser_session.finish_request_state(),
+ crate::live_document_parser::DocumentParserFinishRequestState::Delayed,
+ "the requesting turn must record an explicitly delayed finish"
+ );
assert!(
phase_runtime
.page_vm
@@ -3947,7 +3962,6 @@ document.body.setAttribute('data-error-state', [
"deferred finish must cross a selected Page task boundary"
);
- drop(insertion_controller);
let request_client = phase_runtime
.page_vm
.main_document_resource_loader()
@@ -3965,17 +3979,28 @@ document.body.setAttribute('data-error-state', [
"the exact deferred-finish continuation should remain selectable"
);
+ // Keep the insertion bridge alive across finalization. Its weak
+ // stream capability must not participate in parser ownership.
let completion = ParseTimePhaseOnePump::new(phase_runtime)
.run_to_completion()
.await
- .expect("unborrowed parser stream should finish");
- assert!(matches!(
- completion,
- super::loop_protocol::ParseTimeOwnerCompletion::AdvancePhase {
- reason: super::loop_protocol::ParseTimePhaseTransitionReason::ParserCompleted,
- ..
- }
- ));
+ .expect("admitted parser continuation should finish");
+ let super::loop_protocol::ParseTimeOwnerCompletion::AdvancePhase {
+ runtime,
+ reason: super::loop_protocol::ParseTimePhaseTransitionReason::ParserCompleted,
+ } = completion
+ else {
+ panic!("the admitted delayed finish should advance to phase two");
+ };
+ assert_eq!(
+ runtime.state.parser_session.run_state(),
+ crate::live_document_parser::DocumentParserRunState::Finished
+ );
+ assert_eq!(
+ runtime.state.parser_session.finish_request_state(),
+ crate::live_document_parser::DocumentParserFinishRequestState::Admitted
+ );
+ drop(parser_bridge);
}));
}
@@ -4605,14 +4630,14 @@ queueMicrotask(() => window.__mainParserClassicCheckpointEvents.push('script-mic
);
let mut pending_runner =
PendingParsingBlockingClassicScriptRunner::new_parser_blocking(Vec::new());
- let parser_insertion_controller =
- crate::document_runtime::ParserInsertionController::for_session(
+ let parser_bridge =
+ crate::document_runtime::ParserConnectedScriptBridge::for_session(
&state.parser_session,
);
let mut owner = super::parser_blocking_document_script::MainParserBlockingDocumentScriptOwner::new(
&mut page_vm,
&mut pending_runner,
- parser_insertion_controller,
+ parser_bridge,
"test source failure",
);
diff --git a/moli-renderer-v8/src/runtime/phase_one/owner_turn.rs b/moli-renderer-v8/src/runtime/phase_one/owner_turn.rs
index 3e8e7e6c6..240b353a4 100644
--- a/moli-renderer-v8/src/runtime/phase_one/owner_turn.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/owner_turn.rs
@@ -246,7 +246,14 @@ impl ConcurrentParseTimeRuntime {
&& !state.parser_session.has_script_input()
{
if state.input_closed {
- OwnerStepProgress::AdvancePhase
+ // Document work can expose EOF, but
+ // only the phase-one parser owner may
+ // request and claim finalization. Route
+ // through it so the exact continuation
+ // boundary remains mandatory.
+ *parser_step_ready = true;
+ *owner = ParseTimeOwner::Parser;
+ OwnerStepProgress::Continue
} else {
*owner = ParseTimeOwner::Parser;
OwnerStepProgress::NeedMoreInput
diff --git a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_document_script.rs b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_document_script.rs
index be74b076d..3cf914084 100644
--- a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_document_script.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_document_script.rs
@@ -14,7 +14,7 @@ use super::parser_blocking_task::{
MainParserBlockingNextAction,
};
use super::*;
-use crate::document_runtime::ParserInsertionController;
+use crate::document_runtime::ParserConnectedScriptBridge;
use crate::document_script_scheduler::{
DocumentScriptExecutionOutcome, ParserClassicDocumentScriptCompletionPlan,
ParserClassicDocumentScriptContinuation, ParserClassicDocumentScriptExecutionHooks,
@@ -33,7 +33,7 @@ use crate::script_vm::{
pub(super) struct MainParserBlockingDocumentScriptOwner<'page, 'runner> {
page_vm: &'page mut PageVm,
pending_runner: &'runner mut PendingParsingBlockingClassicScriptRunner,
- parser_insertion_controller: Option<ParserInsertionController>,
+ parser_bridge: Option<ParserConnectedScriptBridge>,
log_message: &'static str,
}
@@ -59,13 +59,13 @@ impl<'page, 'runner> MainParserBlockingDocumentScriptOwner<'page, 'runner> {
pub(super) fn new(
page_vm: &'page mut PageVm,
pending_runner: &'runner mut PendingParsingBlockingClassicScriptRunner,
- parser_insertion_controller: Option<ParserInsertionController>,
+ parser_bridge: Option<ParserConnectedScriptBridge>,
log_message: &'static str,
) -> Self {
Self {
page_vm,
pending_runner,
- parser_insertion_controller,
+ parser_bridge,
log_message,
}
}
@@ -149,9 +149,9 @@ impl ParserClassicDocumentScriptExecutionHooks
let owner = &mut **self;
let script_handle = ready_script.script_handle();
let completion_target = *ready_script.target();
- let parser_insertion_controller = owner.parser_insertion_controller.clone();
+ let parser_bridge = owner.parser_bridge.clone();
let mut begin_owner = MainParserBlockingBeginExecutionOwner {
- parser_insertion_controller,
+ parser_bridge,
completion_target,
};
let Some(execution_entry) = owner
@@ -186,7 +186,7 @@ impl ParserClassicDocumentScriptExecutionHooks
let completion_target = target.completion_target();
let live_execution = ParseTimeLiveExecution::ParserOwnedClassicScript {
execution_context: ParserOwnedClassicScriptExecutionContext::ParserBlocking {
- insertion_controller: target.parser_insertion_controller(),
+ parser_bridge: target.parser_bridge(),
},
script: Box::new(executable_script.into_prepared_script()),
};
@@ -272,7 +272,7 @@ impl ParserClassicDocumentScriptExecutionHooks
let completion = MainParserBlockingClassicScriptCompletionAction::new(
target,
ParserOwnedClassicScriptCompletion::parser_blocking_source_failure(
- owner.parser_insertion_controller.clone(),
+ owner.parser_bridge.clone(),
event,
),
);
diff --git a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_execution.rs b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_execution.rs
index ca1d6f8ef..46060a5f8 100644
--- a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_execution.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_execution.rs
@@ -3,7 +3,7 @@ use super::parser_blocking_owner::MainParserBlockingExecutionGateOwner;
use super::parser_blocking_pending::PendingParsingBlockingClassicScriptRunner;
use super::parser_blocking_task::PendingParsingBlockingClassicScriptBlockedOnExecution;
use super::*;
-use crate::document_runtime::ParserInsertionController;
+use crate::document_runtime::ParserConnectedScriptBridge;
use crate::document_script_scheduler::DocumentScriptExecutionOutcome;
use crate::live_document_parser::{DocumentParserSession, ParserStopReason};
use crate::parser_script::owner::ParserScriptExecutionBlocker;
@@ -60,7 +60,7 @@ pub(super) async fn resolve_main_parser_blocking_classic_after_runtime_gate(
parser_session.stop(ParserStopReason::DocumentReplacement);
return Ok(MainParserBlockingExecutionOutcome::StoppedCurrentDocument);
}
- let parser_insertion_controller = ParserInsertionController::for_session(parser_session);
+ let parser_bridge = ParserConnectedScriptBridge::for_session(parser_session);
page_vm.vm_mut().sync_live_document_style_sources();
let next_projection = {
let mut owner = MainParserBlockingExecutionGateOwner { page_vm };
@@ -70,7 +70,7 @@ pub(super) async fn resolve_main_parser_blocking_classic_after_runtime_gate(
let mut document_script_owner = MainParserBlockingDocumentScriptOwner::new(
page_vm,
pending_runner,
- parser_insertion_controller,
+ parser_bridge,
log_message,
);
let action = match next_projection {
diff --git a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_owner.rs b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_owner.rs
index 0829bd77a..b52738147 100644
--- a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_owner.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_owner.rs
@@ -9,7 +9,7 @@ use super::parser_blocking_task::{
};
use super::*;
use crate::DocumentBlockingStylesheetSignature;
-use crate::document_runtime::ParserInsertionController;
+use crate::document_runtime::ParserConnectedScriptBridge;
use crate::document_script_scheduler::MainDocumentClassicScriptTarget;
use crate::frame_owner_model::FrameDocumentTaskOwner;
use crate::parser_script::action::{
@@ -44,7 +44,7 @@ pub(super) struct MainParserBlockingExecutionGateOwner<'a> {
}
pub(super) struct MainParserBlockingBeginExecutionOwner {
- pub(super) parser_insertion_controller: Option<ParserInsertionController>,
+ pub(super) parser_bridge: Option<ParserConnectedScriptBridge>,
pub(super) completion_target: MainDocumentClassicScriptTarget,
}
@@ -308,7 +308,7 @@ impl ParserScriptBeginExecutionOwner<PendingParsingBlockingClassicScriptContext>
action: ParserPendingClassicScriptBeginExecutionAction,
) -> Option<Self::BeginExecutionAction> {
Some(main_parser_blocking_begin_execution_action(
- self.parser_insertion_controller.clone(),
+ self.parser_bridge.clone(),
self.completion_target,
action,
))
diff --git a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_task.rs b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_task.rs
index 00b0d2b93..1de32538c 100644
--- a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_task.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_task.rs
@@ -1,7 +1,7 @@
use super::parser_blocking_pending::{
PendingParsingBlockingClassicScript, PendingParsingBlockingClassicScriptContext,
};
-use crate::document_runtime::ParserInsertionController;
+use crate::document_runtime::ParserConnectedScriptBridge;
use crate::document_script_scheduler::{
MainDocumentClassicReadyWork, MainDocumentClassicScriptTarget,
MainDocumentClassicSourceFailureWork,
@@ -61,23 +61,23 @@ impl MainParserBlockingClassicScriptCompletionAction {
#[derive(Clone)]
pub(super) struct MainParserBlockingClassicScriptExecutionTarget {
- parser_insertion_controller: Option<ParserInsertionController>,
+ parser_bridge: Option<ParserConnectedScriptBridge>,
completion_target: MainDocumentClassicScriptTarget,
}
impl MainParserBlockingClassicScriptExecutionTarget {
pub(super) fn new(
- parser_insertion_controller: Option<ParserInsertionController>,
+ parser_bridge: Option<ParserConnectedScriptBridge>,
completion_target: MainDocumentClassicScriptTarget,
) -> Self {
Self {
- parser_insertion_controller,
+ parser_bridge,
completion_target,
}
}
- pub(super) fn parser_insertion_controller(&self) -> Option<ParserInsertionController> {
- self.parser_insertion_controller.clone()
+ pub(super) fn parser_bridge(&self) -> Option<ParserConnectedScriptBridge> {
+ self.parser_bridge.clone()
}
pub(super) fn completion_target(&self) -> MainDocumentClassicScriptTarget {
@@ -94,15 +94,12 @@ pub(super) fn main_parser_blocking_ready_action(
}
pub(super) fn main_parser_blocking_begin_execution_action(
- parser_insertion_controller: Option<ParserInsertionController>,
+ parser_bridge: Option<ParserConnectedScriptBridge>,
completion_target: MainDocumentClassicScriptTarget,
action: ParserPendingClassicScriptBeginExecutionAction,
) -> MainParserBlockingClassicScriptExecutionEntry {
ParserClassicScriptBeginExecutionAction::from_pending_begin_execution_action(
- MainParserBlockingClassicScriptExecutionTarget::new(
- parser_insertion_controller,
- completion_target,
- ),
+ MainParserBlockingClassicScriptExecutionTarget::new(parser_bridge, completion_target),
action,
)
}
diff --git a/moli-renderer-v8/src/runtime/phase_one/parser_turn.rs b/moli-renderer-v8/src/runtime/phase_one/parser_turn.rs
index 21b7e53d8..8babe5985 100644
--- a/moli-renderer-v8/src/runtime/phase_one/parser_turn.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/parser_turn.rs
@@ -19,7 +19,8 @@ use super::*;
use crate::document_runtime::parser_script_preparation_failure_page_owned_work;
use crate::dom::native::{Attribute, DomMutationEffects, NativeNodeId};
use crate::live_document_parser::{
- LiveDocumentParserOwner, LiveDocumentParserStepOutcome, ParserSuspensionCause,
+ DocumentParserFinishRequestState, LiveDocumentParserOwner, LiveDocumentParserStepOutcome,
+ ParserSuspensionCause,
};
use crate::parser::{
ParserDomMutation, ParserDomMutationConsumer, ParserDomReadConsumer,
@@ -553,10 +554,7 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {
{
if self.parser_session.input_is_empty() {
if *self.input_closed {
- return Ok(self.finish_main_parser_or_defer_borrowed_stream(
- page_vm,
- parser_document_owner,
- ));
+ return Ok(self.request_or_finish_main_parser(page_vm, parser_document_owner));
}
return Ok(OwnerStepProgress::NeedMoreInput);
}
@@ -680,7 +678,7 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {
*parser_step_ready = false;
let progress = if self.parser_session.input_is_empty() {
if *self.input_closed {
- self.finish_main_parser_or_defer_borrowed_stream(page_vm, parser_document_owner)
+ self.request_or_finish_main_parser(page_vm, parser_document_owner)
} else {
OwnerStepProgress::NeedMoreInput
}
@@ -1305,27 +1303,37 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {
outcome
}
- fn finish_main_parser_or_defer_borrowed_stream(
+ fn request_or_finish_main_parser(
&mut self,
page_vm: &mut PageVm,
parser_document_owner: crate::frame_owner_model::FrameDocumentTaskOwner,
) -> OwnerStepProgress {
- if !self.parser_session.has_exclusive_stream_handle() {
- // A document.write recovery turn can drive this same main stream
- // to EOF while its temporary ParserInsertionController is still
- // live on the Page-task stack. EOF is final, but destroying the
- // stream is only valid after that stack has unwound. Cross the
- // stable scheduler boundary once; the selected continuation then
- // re-enters this sole parser runtime with exclusive ownership.
+ if self.parser_session.finish_request_state()
+ == DocumentParserFinishRequestState::NotRequested
+ {
+ // Low-level fixtures can close their input flag directly. The
+ // production input boundary records this before pumping begins.
+ self.parser_session.request_finish();
+ }
+ if self.parser_session.finish_request_state() == DocumentParserFinishRequestState::Delayed {
+ // A parser-connected script, suspension, or reentrant pump kept
+ // work active after EOF was requested. Preserve that historical
+ // fact even after the stack unwinds and require the exact
+ // phase-one continuation to admit finalization.
assert!(
page_vm
.vm()
.document_runtime
.request_main_parser_continuation_if_active(),
- "main parser EOF with a borrowed stream requires an active continuation route"
+ "main parser EOF requires an active phase-one continuation route"
);
return OwnerStepProgress::BlockedOnPageTask;
}
+ debug_assert!(matches!(
+ self.parser_session.finish_request_state(),
+ DocumentParserFinishRequestState::Requested
+ | DocumentParserFinishRequestState::Admitted
+ ));
self.finish_main_parser(page_vm, parser_document_owner);
OwnerStepProgress::AdvancePhase
}
diff --git a/moli-renderer-v8/src/runtime/phase_one/state.rs b/moli-renderer-v8/src/runtime/phase_one/state.rs
index c70916171..54d48526d 100644
--- a/moli-renderer-v8/src/runtime/phase_one/state.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/state.rs
@@ -39,6 +39,14 @@ impl ParseTimeDriverState {
input_closed: false,
}
}
+
+ pub(super) fn close_input(&mut self) {
+ if self.input_closed {
+ return;
+ }
+ self.parser_session.request_finish();
+ self.input_closed = true;
+ }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -225,6 +233,10 @@ impl ConcurrentParseTimeRuntime {
{
return false;
}
+ let _ = self
+ .state
+ .parser_session
+ .admit_delayed_finish_continuation();
self.owner = ParseTimeOwner::Parser;
self.parser_step_ready = true;
self.pending_parsing_blocking_wait = PendingParsingBlockingWait::None;
diff --git a/moli-renderer-v8/src/runtime/phase_one/streaming.rs b/moli-renderer-v8/src/runtime/phase_one/streaming.rs
index edb798a3b..045693ed4 100644
--- a/moli-renderer-v8/src/runtime/phase_one/streaming.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/streaming.rs
@@ -551,7 +551,7 @@ impl ConcurrentParseTimeRuntime {
}
pub(super) fn close_streaming_html_input(&mut self) {
- self.state.input_closed = true;
+ self.state.close_input();
}
pub(super) async fn continue_streaming_creation_on_execution_context(
diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs
index fe06c76d0..dae33cfba 100644
--- a/moli-renderer-v8/src/script_vm.rs
+++ b/moli-renderer-v8/src/script_vm.rs
@@ -5810,7 +5810,7 @@ impl ScriptVm {
.set_current_script_context(CurrentScriptContextSpec {
handle: run_input.current_script,
parser_write_insertion_point_active: run_input.parser_write_insertion_point_active,
- parser_insertion_controller: None,
+ parser_bridge: None,
});
let document_owner_before_run =
self.current_main_document_task_owner().ok_or_else(|| {
@@ -7932,12 +7932,12 @@ impl ScriptVm {
);
}
};
- let parser_insertion_controller = match (
+ let parser_bridge = match (
run_input.current_script,
run_input.parser_write_insertion_point_active,
- execution_context.parser_insertion_controller(),
+ execution_context.parser_bridge(),
) {
- (Some(_), true, Some(controller)) => Some(controller.clone()),
+ (Some(_), true, Some(bridge)) => Some(bridge.clone()),
_ => None,
};
// XML parser-blocking scripts have a currentScript and use the same
@@ -7945,12 +7945,12 @@ impl ScriptVm {
// Absence of a controller therefore means document.write is inactive;
// it must not suppress otherwise valid XHTML/SVG script execution.
let parser_write_insertion_point_active =
- run_input.parser_write_insertion_point_active && parser_insertion_controller.is_some();
+ run_input.parser_write_insertion_point_active && parser_bridge.is_some();
self.document_runtime
.set_current_script_context(CurrentScriptContextSpec {
handle: run_input.current_script,
parser_write_insertion_point_active,
- parser_insertion_controller,
+ parser_bridge,
});
let document_owner_before_run = self
.current_main_document_task_owner()
@@ -8066,7 +8066,7 @@ impl ScriptVm {
.set_current_script_context(CurrentScriptContextSpec {
handle: run_input.current_script,
parser_write_insertion_point_active: run_input.parser_write_insertion_point_active,
- parser_insertion_controller: None,
+ parser_bridge: None,
});
let result = self
.execute_prepared_script_run_body(script, run_input.body)
diff --git a/moli-renderer-v8/src/script_vm/main_parser_classic_completion.rs b/moli-renderer-v8/src/script_vm/main_parser_classic_completion.rs
index 5f2898efd..ebef2e55a 100644
--- a/moli-renderer-v8/src/script_vm/main_parser_classic_completion.rs
+++ b/moli-renderer-v8/src/script_vm/main_parser_classic_completion.rs
@@ -87,17 +87,16 @@ impl ScriptVm {
let mut application = ParserOwnedClassicScriptCompletionApplication::default();
application.note_completion_applied(evaluation);
let terminal_activity = if let Some(task) = script_element_event {
- let _parser_script_nesting = execution_context
- .is_parser_blocking()
- .then(|| self.document_runtime.enter_parser_script_nesting());
- let parser_insertion_controller =
- execution_context.parser_insertion_controller().cloned();
+ let parser_bridge = execution_context.parser_bridge().cloned();
self.document_runtime
.set_current_script_context(CurrentScriptContextSpec {
handle: None,
- parser_write_insertion_point_active: parser_insertion_controller.is_some(),
- parser_insertion_controller,
+ parser_write_insertion_point_active: parser_bridge.is_some(),
+ parser_bridge,
});
+ let _parser_script_nesting = execution_context
+ .is_parser_blocking()
+ .then(|| self.document_runtime.enter_parser_script_nesting());
let dispatch = self.dispatch_script_event_body(&task);
self.document_runtime.clear_current_script_handle();
match dispatch {
diff --git a/moli-renderer-v8/src/script_vm/parser_owned_classic.rs b/moli-renderer-v8/src/script_vm/parser_owned_classic.rs
index de6c046f0..19fd94c2b 100644
--- a/moli-renderer-v8/src/script_vm/parser_owned_classic.rs
+++ b/moli-renderer-v8/src/script_vm/parser_owned_classic.rs
@@ -6,7 +6,7 @@
//! "finished" from a script handle, an event, or a compatibility boolean.
use super::{PreparedScriptBodyActivity, ScriptTerminalBodyActivity};
-use crate::{document_runtime::ParserInsertionController, host::ScriptEventTask};
+use crate::{document_runtime::ParserConnectedScriptBridge, host::ScriptEventTask};
#[derive(Debug)]
pub(crate) struct ParserOwnedClassicScriptExecutionError {
@@ -79,7 +79,7 @@ impl ParserOwnedClassicScriptExecutionReport {
#[derive(Clone, Debug)]
pub(crate) enum ParserOwnedClassicScriptExecutionContext {
ParserBlocking {
- insertion_controller: Option<ParserInsertionController>,
+ parser_bridge: Option<ParserConnectedScriptBridge>,
},
Deferred,
}
@@ -89,11 +89,9 @@ impl ParserOwnedClassicScriptExecutionContext {
matches!(self, Self::ParserBlocking { .. })
}
- pub(crate) fn parser_insertion_controller(&self) -> Option<&ParserInsertionController> {
+ pub(crate) fn parser_bridge(&self) -> Option<&ParserConnectedScriptBridge> {
match self {
- Self::ParserBlocking {
- insertion_controller,
- } => insertion_controller.as_ref(),
+ Self::ParserBlocking { parser_bridge } => parser_bridge.as_ref(),
Self::Deferred => None,
}
}
@@ -119,12 +117,12 @@ impl ParserOwnedClassicScriptCompletion {
}
pub(crate) fn parser_blocking_source_failure(
- parser_insertion_controller: Option<ParserInsertionController>,
+ parser_bridge: Option<ParserConnectedScriptBridge>,
script_element_event: Option<ScriptEventTask>,
) -> Self {
Self {
execution_context: ParserOwnedClassicScriptExecutionContext::ParserBlocking {
- insertion_controller: parser_insertion_controller,
+ parser_bridge,
},
script_element_event,
evaluation: ParserOwnedClassicScriptEvaluationSettlement::NotSettled,
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/misc.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/misc.rs
index 68804f991..b7704c496 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/misc.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/misc.rs
@@ -171,7 +171,7 @@ fn current_script_is_null_while_script_remains_in_shadow_tree() {
.set_current_script_context(CurrentScriptContextSpec {
handle: Some(outer),
parser_write_insertion_point_active: false,
- parser_insertion_controller: None,
+ parser_bridge: None,
});
vm.exec(
r#"
@@ -220,7 +220,7 @@ fn current_script_is_null_while_script_remains_in_shadow_tree() {
.set_current_script_context(CurrentScriptContextSpec {
handle: Some(script),
parser_write_insertion_point_active: false,
- parser_insertion_controller: None,
+ parser_bridge: None,
});
assert_eq!(
vm.eval("String(document.currentScript)")
@@ -235,7 +235,7 @@ fn current_script_is_null_while_script_remains_in_shadow_tree() {
.set_current_script_context(CurrentScriptContextSpec {
handle: Some(script),
parser_write_insertion_point_active: false,
- parser_insertion_controller: None,
+ parser_bridge: None,
});
assert_eq!(
vm.eval("document.currentScript && document.currentScript.id")