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): centralize pending parser blocking work

ldm0cd0c82e5bac8
diff --git a/moli-renderer-v8/src/document_runtime.rs b/moli-renderer-v8/src/document_runtime.rs
index 1405d4686..2ac8970b2 100644
--- a/moli-renderer-v8/src/document_runtime.rs
+++ b/moli-renderer-v8/src/document_runtime.rs
@@ -16,6 +16,7 @@ mod lifecycle;
mod main_parser_continuation;
mod meta_refresh;
mod mutation_commands;
+mod parser_blocking;
mod parser_modulepreload;
mod query_facade;
mod runtime_core;
@@ -76,6 +77,7 @@ pub(crate) use devtools_mutations::{
};
pub(crate) use inspector_issues::PendingInspectorIssue;
pub(crate) use meta_refresh::MetaRefreshNavigation;
+use parser_blocking::{ParserInsertionWork, PendingParserBlockingWork, PendingParserInsertion};
pub(crate) use parser_modulepreload::MainDocumentModulepreloadFetchOutcome;
pub(crate) use script_lifecycle::{
DeferredPageTask, DeferredPageTaskLane, DeferredPageTaskState, DocumentScriptLifecycle,
@@ -450,6 +452,7 @@ struct DocumentWriteExternalScriptStart {
#[derive(Debug)]
struct SuspendedDocumentWriteInsertion {
document_handle: DomHandle,
+ document_incarnation: DocumentRuntimeIncarnationIdentity,
parser_bridge: ParserConnectedScriptBridge,
resume_permit: ParserResumePermit,
resume_permit_consumed: bool,
@@ -468,19 +471,6 @@ enum SuspendedDocumentWriteContinuation {
},
}
-#[derive(Debug)]
-struct PendingDocumentWriteExternalScriptLoad {
- target: crate::types::DocumentWriteExternalScriptFetchTarget,
- start: DocumentWriteExternalScriptStart,
- insertion: SuspendedDocumentWriteInsertion,
- /// Stylesheets preceding this parser-inserted script. Their fetches run
- /// in parallel with the script source, but their owner events and style
- /// installation must complete before the source can execute.
- blocking_signatures_before: HashSet<DocumentBlockingStylesheetSignature>,
- ready_completion: Option<crate::types::DocumentWriteExternalScriptLoadCompletion>,
- resume_after_completion: VecDeque<SuspendedDocumentWriteContinuation>,
-}
-
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum DocumentWriteExternalScriptLoadApplication {
Applied,
@@ -495,31 +485,6 @@ struct DocumentWriteScriptPreload {
ready_completion: Option<crate::types::DocumentWriteExternalScriptLoadCompletion>,
}
-/// A parser-blocking script reached by a live `document.write`-style parser
-/// while one of the stylesheets that preceded it is still unresolved.
-///
-/// The parser stream and its insertion point stay owned by the document
-/// runtime. A stylesheet-completion owner turn resumes this exact handoff;
-/// CDP/document callers never wait on the network operation themselves.
-#[derive(Debug)]
-struct PendingDocumentWriteStylesheetBlockedScript {
- node: DomHandle,
- start_line: u64,
- start_column: u64,
- script: PreparedScript,
- blocking_signatures_before: HashSet<DocumentBlockingStylesheetSignature>,
- insertion: SuspendedDocumentWriteInsertion,
-}
-
-/// Parser-created blocking stylesheet boundary with no script attached to it.
-/// Blink pauses token consumption at this boundary until the stylesheet owner
-/// settles, even when the next token is an ordinary element.
-#[derive(Debug)]
-struct PendingDocumentWriteStylesheetParserPause {
- blocking_signatures: HashSet<DocumentBlockingStylesheetSignature>,
- insertion: SuspendedDocumentWriteInsertion,
-}
-
#[derive(Debug)]
enum DocumentWriteScriptRunOutcome {
Complete,
@@ -802,11 +767,7 @@ pub(super) struct DocumentRuntime {
main_document_script_preloads: crate::runtime::DocumentScriptPreloadStore,
document_write_script_preloads:
HashMap<crate::runtime::BufferedScriptPreloadKey, DocumentWriteScriptPreload>,
- pending_document_write_external_script_load: Option<PendingDocumentWriteExternalScriptLoad>,
- pending_document_write_stylesheet_blocked_script:
- Option<PendingDocumentWriteStylesheetBlockedScript>,
- pending_document_write_stylesheet_parser_pause:
- Option<PendingDocumentWriteStylesheetParserPause>,
+ pending_parser_blocking_work: Option<PendingParserBlockingWork>,
}
#[derive(Clone, Debug)]
diff --git a/moli-renderer-v8/src/document_runtime/document_write.rs b/moli-renderer-v8/src/document_runtime/document_write.rs
index 1dbaf3cd8..e9b8a4b0a 100644
--- a/moli-renderer-v8/src/document_runtime/document_write.rs
+++ b/moli-renderer-v8/src/document_runtime/document_write.rs
@@ -990,25 +990,30 @@ impl DocumentRuntime {
}
pub(crate) fn has_pending_document_write_external_script_load(&self) -> bool {
- self.pending_document_write_external_script_load.is_some()
+ self.document_write_external_script_fetch_target().is_some()
+ }
+
+ fn document_write_external_script_fetch_target(
+ &self,
+ ) -> Option<crate::types::DocumentWriteExternalScriptFetchTarget> {
+ match &self.pending_parser_insertion()?.work {
+ ParserInsertionWork::ExternalScript { target, .. } => Some(*target),
+ _ => None,
+ }
}
#[cfg(test)]
pub(crate) fn pending_document_write_external_script_fetch_target(
&self,
) -> Option<crate::types::DocumentWriteExternalScriptFetchTarget> {
- self.pending_document_write_external_script_load
- .as_ref()
- .map(|pending| pending.target)
+ self.document_write_external_script_fetch_target()
}
pub(crate) fn has_document_write_external_script_fetch_target(
&self,
target: crate::types::DocumentWriteExternalScriptFetchTarget,
) -> bool {
- self.pending_document_write_external_script_load
- .as_ref()
- .is_some_and(|pending| pending.target == target)
+ self.document_write_external_script_fetch_target() == Some(target)
|| self
.document_write_script_preloads
.values()
@@ -1016,13 +1021,7 @@ impl DocumentRuntime {
}
pub(crate) fn has_pending_document_write_parser_blocking_work(&self) -> bool {
- self.pending_document_write_external_script_load.is_some()
- || self
- .pending_document_write_stylesheet_blocked_script
- .is_some()
- || self
- .pending_document_write_stylesheet_parser_pause
- .is_some()
+ self.pending_parser_insertion().is_some()
}
pub(crate) fn has_unfinished_root_document_parser_stream(&self) -> bool {
@@ -1030,33 +1029,15 @@ impl DocumentRuntime {
}
pub(crate) fn has_pending_document_write_stylesheet_blocked_script(&self) -> bool {
- self.pending_document_write_stylesheet_blocked_script
- .is_some()
- || self
- .pending_document_write_stylesheet_parser_pause
- .is_some()
- || self
- .pending_document_write_external_script_load
- .as_ref()
- .is_some_and(|pending| !pending.blocking_signatures_before.is_empty())
+ self.pending_parser_insertion()
+ .is_some_and(|pending| !pending.blocking_signatures.is_empty())
}
pub(crate) fn document_write_stylesheet_blocked_script_is_ready(&mut self) -> bool {
let Some(signatures) = self
- .pending_document_write_stylesheet_parser_pause
- .as_ref()
+ .pending_parser_insertion()
+ .filter(|pending| !pending.blocking_signatures.is_empty())
.map(|pending| pending.blocking_signatures.clone())
- .or_else(|| {
- self.pending_document_write_stylesheet_blocked_script
- .as_ref()
- .map(|pending| pending.blocking_signatures_before.clone())
- })
- .or_else(|| {
- self.pending_document_write_external_script_load
- .as_ref()
- .filter(|pending| !pending.blocking_signatures_before.is_empty())
- .map(|pending| pending.blocking_signatures_before.clone())
- })
else {
return false;
};
@@ -1185,63 +1166,17 @@ impl DocumentRuntime {
}
}
- fn append_to_pending_document_write_external_script_load(&mut self, html: &str) -> bool {
- let Some(pending) = self.pending_document_write_external_script_load.as_mut() else {
- return false;
- };
- pending
- .insertion
- .parser_bridge
- .insertion_controller()
- .input_session()
- .enqueue_script_input_html(html.to_owned());
- pending
- .insertion
- .parser_bridge
- .insertion_controller()
- .input_session()
- .enqueue_script_input_preload_html(html.to_owned());
- true
- }
-
- fn append_to_pending_document_write_stylesheet_blocked_script(&mut self, html: &str) -> bool {
- let Some(pending) = self
- .pending_document_write_stylesheet_blocked_script
- .as_mut()
- else {
+ fn append_to_pending_parser_insertion(&mut self, html: &str) -> bool {
+ let Some(pending) = self.pending_parser_insertion() else {
return false;
};
- pending
+ let input = pending
.insertion
.parser_bridge
.insertion_controller()
- .input_session()
- .enqueue_script_input_html(html.to_owned());
- pending
- .insertion
- .parser_bridge
- .insertion_controller()
- .input_session()
- .enqueue_script_input_preload_html(html.to_owned());
- true
- }
-
- fn append_to_pending_document_write_stylesheet_parser_pause(&mut self, html: &str) -> bool {
- let Some(pending) = self.pending_document_write_stylesheet_parser_pause.as_mut() else {
- return false;
- };
- pending
- .insertion
- .parser_bridge
- .insertion_controller()
- .input_session()
- .enqueue_script_input_html(html.to_owned());
- pending
- .insertion
- .parser_bridge
- .insertion_controller()
- .input_session()
- .enqueue_script_input_preload_html(html.to_owned());
+ .input_session();
+ input.enqueue_script_input_html(html.to_owned());
+ input.enqueue_script_input_preload_html(html.to_owned());
true
}
@@ -1253,11 +1188,10 @@ impl DocumentRuntime {
insertion: SuspendedDocumentWriteInsertion,
blocking_signatures_before: HashSet<DocumentBlockingStylesheetSignature>,
) -> bool {
- if let Some(pending) = self.pending_document_write_external_script_load.as_mut() {
+ if let Some(pending) = self.pending_parser_insertion_mut() {
tracing::error!(
- pending_load_id = pending.target.load_id(),
queued_url = %start.script.url,
- "document.write external script load attempted while another load is pending"
+ "document.write external script load attempted while another parser blocker is pending"
);
pending.resume_after_completion.push_back(
SuspendedDocumentWriteContinuation::StartExternal {
@@ -1294,33 +1228,21 @@ impl DocumentRuntime {
start.script.url.clone(),
);
let script_for_load = start.script.clone();
- self.pending_document_write_external_script_load =
- Some(PendingDocumentWriteExternalScriptLoad {
+ let source_ready = ready_completion.is_some();
+ self.install_pending_parser_insertion(PendingParserInsertion {
+ insertion,
+ blocking_signatures: blocking_signatures_before,
+ work: ParserInsertionWork::ExternalScript {
target,
start,
- insertion,
- blocking_signatures_before,
- ready_completion: None,
- resume_after_completion: VecDeque::new(),
- });
- if let Some(completion) = ready_completion {
- if self
- .pending_document_write_external_script_load
- .as_ref()
- .is_some_and(|pending| !pending.blocking_signatures_before.is_empty())
- {
- self.pending_document_write_external_script_load
- .as_mut()
- .expect("preloaded script must retain its pending owner")
- .ready_completion = Some(completion);
- return true;
- }
- let pending = self
- .pending_document_write_external_script_load
- .take()
- .expect("ready preloaded script must retain its pending owner");
- let _ = self
- .finish_document_write_external_script_load(scope, host_ptr, pending, completion);
+ ready_completion: ready_completion.map(Box::new),
+ },
+ resume_after_completion: VecDeque::new(),
+ });
+ // Both source and stylesheet completion use the same readiness check.
+ // Take the work before executing; nested writes may install a new one.
+ if source_ready {
+ let _ = self.resume_ready_parser_insertion(scope, host_ptr);
return true;
}
if preload_was_started {
@@ -1355,7 +1277,7 @@ impl DocumentRuntime {
&mut self,
mut continuations: VecDeque<SuspendedDocumentWriteContinuation>,
) {
- let Some(pending) = self.pending_document_write_external_script_load.as_mut() else {
+ let Some(pending) = self.pending_parser_insertion_mut() else {
debug_assert!(
continuations.is_empty(),
"document.write continuations should only be queued behind an active pending load"
@@ -1402,20 +1324,23 @@ impl DocumentRuntime {
&mut self,
scope: &mut v8::PinScope<'_, '_>,
host_ptr: *mut JsContextHost,
- first: SuspendedDocumentWriteContinuation,
mut remaining: VecDeque<SuspendedDocumentWriteContinuation>,
) -> bool {
let mut changed = false;
- let mut next = Some(first);
- while let Some(continuation) = next {
- if self.resume_document_write_continuation(scope, host_ptr, continuation) {
- changed = true;
+ while let Some(continuation) = remaining.pop_front() {
+ let insertion = match &continuation {
+ SuspendedDocumentWriteContinuation::ResumeAfterCompleted { insertion, .. }
+ | SuspendedDocumentWriteContinuation::StartExternal { insertion, .. } => insertion,
+ };
+ if insertion.document_incarnation != self.document_incarnation {
+ continue;
}
- if self.pending_document_write_external_script_load.is_some() {
+ if self.has_pending_document_write_parser_blocking_work() {
+ remaining.push_front(continuation);
self.queue_document_write_continuations_after_pending(remaining);
return true;
}
- next = remaining.pop_front();
+ changed |= self.resume_document_write_continuation(scope, host_ptr, continuation);
}
changed
}
@@ -1426,6 +1351,9 @@ impl DocumentRuntime {
host_ptr: *mut JsContextHost,
mut insertion: SuspendedDocumentWriteInsertion,
) -> bool {
+ if insertion.document_incarnation != self.document_incarnation {
+ return false;
+ }
if self.park_suspended_insertion_behind_reentrant_parser_work(&mut insertion) {
return true;
}
@@ -1562,11 +1490,7 @@ impl DocumentRuntime {
completion: crate::types::DocumentWriteExternalScriptLoadCompletion,
) -> super::DocumentWriteExternalScriptLoadApplication {
let completion_target = completion.target();
- if self
- .pending_document_write_external_script_load
- .as_ref()
- .is_none_or(|pending| pending.target != completion_target)
- {
+ if self.document_write_external_script_fetch_target() != Some(completion_target) {
return if self.complete_document_write_script_preload(completion) {
super::DocumentWriteExternalScriptLoadApplication::Applied
} else {
@@ -1578,44 +1502,46 @@ impl DocumentRuntime {
{
return super::DocumentWriteExternalScriptLoadApplication::RejectedStaleTarget;
}
- let mut pending = self
- .pending_document_write_external_script_load
- .take()
- .expect("matching document-write script completion must retain its pending owner");
- if pending.target != completion_target
- || unsafe { &*host_ptr }.current_main_document_task_owner()
- != Some(completion_target.task_owner())
- {
- self.pending_document_write_external_script_load = Some(pending);
+ let pending = self
+ .pending_parser_insertion_mut()
+ .expect("matching script completion must retain its pending owner");
+ let ParserInsertionWork::ExternalScript {
+ ready_completion, ..
+ } = &mut pending.work
+ else {
+ unreachable!()
+ };
+ // A repeated delivery is stale even if stylesheets still keep the
+ // first terminal parked. It must never replace an accepted result.
+ if ready_completion.is_some() {
return super::DocumentWriteExternalScriptLoadApplication::RejectedStaleTarget;
}
- if !pending.blocking_signatures_before.is_empty() {
- debug_assert!(
- pending.ready_completion.is_none(),
- "one external parser script load must produce exactly one completion"
- );
- pending.ready_completion = Some(completion);
- self.pending_document_write_external_script_load = Some(pending);
- return super::DocumentWriteExternalScriptLoadApplication::Applied;
- }
-
- self.finish_document_write_external_script_load(scope, host_ptr, pending, completion)
+ *ready_completion = Some(Box::new(completion));
+ self.resume_ready_parser_insertion(scope, host_ptr)
+ .unwrap_or(super::DocumentWriteExternalScriptLoadApplication::Applied)
}
fn finish_document_write_external_script_load(
&mut self,
scope: &mut v8::PinScope<'_, '_>,
host_ptr: *mut JsContextHost,
- pending: PendingDocumentWriteExternalScriptLoad,
- completion: crate::types::DocumentWriteExternalScriptLoadCompletion,
+ pending: PendingParserInsertion,
) -> super::DocumentWriteExternalScriptLoadApplication {
- let completion_target = completion.target();
- let PendingDocumentWriteExternalScriptLoad {
- start,
+ let PendingParserInsertion {
mut insertion,
mut resume_after_completion,
+ work,
..
} = pending;
+ let ParserInsertionWork::ExternalScript {
+ start,
+ ready_completion: Some(completion),
+ ..
+ } = work
+ else {
+ unreachable!("only a ready external source can be executed")
+ };
+ let completion_target = completion.target();
if !Self::resume_document_write_insertion_permit(&mut insertion) {
tracing::debug!(
target = ?completion_target,
@@ -1699,19 +1625,10 @@ impl DocumentRuntime {
return super::DocumentWriteExternalScriptLoadApplication::SupersededDuringApplication;
}
- let first = SuspendedDocumentWriteContinuation::ResumeAfterCompleted { start, insertion };
- if self.pending_document_write_external_script_load.is_some() {
- resume_after_completion.push_front(first);
- self.queue_document_write_continuations_after_pending(resume_after_completion);
- return super::DocumentWriteExternalScriptLoadApplication::Applied;
- }
-
- let _ = self.resume_document_write_continuations(
- scope,
- host_ptr,
- first,
- resume_after_completion,
+ resume_after_completion.push_front(
+ SuspendedDocumentWriteContinuation::ResumeAfterCompleted { start, insertion },
);
+ let _ = self.resume_document_write_continuations(scope, host_ptr, resume_after_completion);
let _ = self.finish_root_document_parser_stream_if_ready(scope, host_ptr);
if unsafe { &*host_ptr }.current_main_document_task_owner()
== Some(completion_target.task_owner())
@@ -1767,6 +1684,7 @@ impl DocumentRuntime {
) -> SuspendedDocumentWriteInsertion {
SuspendedDocumentWriteInsertion {
document_handle,
+ document_incarnation: self.document_incarnation.clone(),
parser_bridge: parser_bridge.clone(),
resume_permit: parser_bridge.suspend(cause),
resume_permit_consumed: false,
@@ -1783,11 +1701,6 @@ impl DocumentRuntime {
script: PreparedScript,
blocking_signatures_before: HashSet<DocumentBlockingStylesheetSignature>,
) -> bool {
- debug_assert!(
- self.pending_document_write_stylesheet_blocked_script
- .is_none(),
- "a live parser can only have one pending parser-blocking script"
- );
self.note_parser_script_start_position(node, start_line, start_column);
let _ = self.dom_host_mut().set_script_already_started(node, true);
let insertion = self.take_suspended_document_write_insertion(
@@ -1795,15 +1708,17 @@ impl DocumentRuntime {
parser_bridge,
ParserSuspensionCause::ParserClassicStylesheets { script: node },
);
- self.pending_document_write_stylesheet_blocked_script =
- Some(PendingDocumentWriteStylesheetBlockedScript {
+ self.install_pending_parser_insertion(PendingParserInsertion {
+ insertion,
+ blocking_signatures: blocking_signatures_before,
+ work: ParserInsertionWork::Script {
node,
start_line,
start_column,
script,
- blocking_signatures_before,
- insertion,
- });
+ },
+ resume_after_completion: VecDeque::new(),
+ });
true
}
@@ -1815,11 +1730,6 @@ impl DocumentRuntime {
stylesheet_owner: DomHandle,
blocking_signatures: HashSet<DocumentBlockingStylesheetSignature>,
) -> bool {
- debug_assert!(
- self.pending_document_write_stylesheet_parser_pause
- .is_none(),
- "a live parser can only have one stylesheet parser boundary"
- );
let insertion = self.take_suspended_document_write_insertion(
document_handle,
parser_bridge,
@@ -1831,11 +1741,12 @@ impl DocumentRuntime {
.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 {
- blocking_signatures,
- insertion,
- });
+ self.install_pending_parser_insertion(PendingParserInsertion {
+ insertion,
+ blocking_signatures,
+ work: ParserInsertionWork::StylesheetBoundary,
+ resume_after_completion: VecDeque::new(),
+ });
true
}
@@ -1884,53 +1795,82 @@ impl DocumentRuntime {
scope: &mut v8::PinScope<'_, '_>,
host_ptr: *mut JsContextHost,
) -> bool {
- if !self.document_write_stylesheet_blocked_script_is_ready() {
- return false;
- }
- if let Some(pending) = self.pending_document_write_stylesheet_parser_pause.take() {
- self.document_write_script_preload_scanner = None;
- let _ =
- self.resume_suspended_document_write_insertion(scope, host_ptr, pending.insertion);
- let _ = self.finish_root_document_parser_stream_if_ready(scope, host_ptr);
- return true;
+ self.resume_ready_parser_insertion(scope, host_ptr)
+ .is_some()
+ }
+
+ /// Resource notifications update the pending work, then enter this common
+ /// gate. Neither source completion nor stylesheet completion can execute
+ /// a script while the other prerequisite remains unresolved.
+ fn resume_ready_parser_insertion(
+ &mut self,
+ scope: &mut v8::PinScope<'_, '_>,
+ host_ptr: *mut JsContextHost,
+ ) -> Option<DocumentWriteExternalScriptLoadApplication> {
+ let signatures = self.pending_parser_insertion()?.blocking_signatures.clone();
+ if self.has_pending_parser_script_blocking_stylesheet_signatures(signatures.iter()) {
+ return None;
+ }
+ let pending = self.pending_parser_insertion_mut()?;
+ pending.blocking_signatures.clear();
+ if matches!(
+ &pending.work,
+ ParserInsertionWork::ExternalScript {
+ ready_completion: None,
+ ..
+ }
+ ) {
+ return (!signatures.is_empty())
+ .then_some(DocumentWriteExternalScriptLoadApplication::Applied);
}
- if self
- .pending_document_write_stylesheet_blocked_script
- .is_none()
- {
- let ready_completion = {
- let Some(pending) = self.pending_document_write_external_script_load.as_mut()
- else {
- return false;
- };
- pending.blocking_signatures_before.clear();
- pending.ready_completion.take()
- };
- let Some(completion) = ready_completion else {
- // The stylesheet side is ready; the same pending parser script
- // now waits only for its source. Element events are separate
- // tasks and do not participate in this gate.
- return true;
- };
- let pending = self
- .pending_document_write_external_script_load
- .take()
- .expect("ready external parser script must retain its pending owner");
- let _ = self
- .finish_document_write_external_script_load(scope, host_ptr, pending, completion);
- return true;
+ let pending = self.take_pending_parser_insertion()?;
+ match &pending.work {
+ ParserInsertionWork::ExternalScript { .. } => {
+ Some(self.finish_document_write_external_script_load(scope, host_ptr, pending))
+ }
+ ParserInsertionWork::Script { .. } => {
+ self.finish_stylesheet_blocked_parser_script(scope, host_ptr, pending);
+ Some(DocumentWriteExternalScriptLoadApplication::Applied)
+ }
+ ParserInsertionWork::StylesheetBoundary => {
+ self.document_write_script_preload_scanner = None;
+ let _ = self.resume_suspended_document_write_insertion(
+ scope,
+ host_ptr,
+ pending.insertion,
+ );
+ let _ = self.resume_document_write_continuations(
+ scope,
+ host_ptr,
+ pending.resume_after_completion,
+ );
+ let _ = self.finish_root_document_parser_stream_if_ready(scope, host_ptr);
+ Some(DocumentWriteExternalScriptLoadApplication::Applied)
+ }
}
- let Some(pending) = self.pending_document_write_stylesheet_blocked_script.take() else {
- return false;
- };
- let PendingDocumentWriteStylesheetBlockedScript {
+ }
+
+ fn finish_stylesheet_blocked_parser_script(
+ &mut self,
+ scope: &mut v8::PinScope<'_, '_>,
+ host_ptr: *mut JsContextHost,
+ pending: PendingParserInsertion,
+ ) -> bool {
+ let PendingParserInsertion {
+ mut insertion,
+ work,
+ resume_after_completion,
+ ..
+ } = pending;
+ let ParserInsertionWork::Script {
node,
start_line,
start_column,
script,
- blocking_signatures_before: _,
- mut insertion,
- } = pending;
+ } = work
+ else {
+ unreachable!()
+ };
if !Self::resume_document_write_insertion_permit(&mut insertion) {
return false;
}
@@ -1944,6 +1884,9 @@ impl DocumentRuntime {
Some(insertion.parser_bridge.clone()),
) {
DocumentWriteScriptRunOutcome::Complete => {
+ if insertion.document_incarnation != self.document_incarnation {
+ return false;
+ }
let parser_bridge = insertion.parser_bridge.clone();
self.set_current_script_context(CurrentScriptContextSpec {
handle: Some(node),
@@ -1952,10 +1895,18 @@ impl DocumentRuntime {
});
let _ = self.resume_suspended_document_write_insertion(scope, host_ptr, insertion);
self.clear_current_script_handle();
+ let _ = self.resume_document_write_continuations(
+ scope,
+ host_ptr,
+ resume_after_completion,
+ );
let _ = self.finish_root_document_parser_stream_if_ready(scope, host_ptr);
true
}
DocumentWriteScriptRunOutcome::Suspend(start) => {
+ if insertion.document_incarnation != self.document_incarnation {
+ return false;
+ }
Self::resuspend_document_write_insertion(
&mut insertion,
ParserSuspensionCause::ParserClassicSource { script: node },
@@ -1967,6 +1918,11 @@ impl DocumentRuntime {
insertion,
HashSet::new(),
);
+ let _ = self.resume_document_write_continuations(
+ scope,
+ host_ptr,
+ resume_after_completion,
+ );
true
}
}
@@ -2537,13 +2493,7 @@ impl DocumentRuntime {
if self.has_pending_document_write_parser_blocking_work() {
self.scan_document_write_script_preloads(host_ptr, html, false);
}
- if self.append_to_pending_document_write_external_script_load(html) {
- return true;
- }
- if self.append_to_pending_document_write_stylesheet_blocked_script(html) {
- return true;
- }
- if self.append_to_pending_document_write_stylesheet_parser_pause(html) {
+ if self.append_to_pending_parser_insertion(html) {
return true;
}
diff --git a/moli-renderer-v8/src/document_runtime/lifecycle.rs b/moli-renderer-v8/src/document_runtime/lifecycle.rs
index 900034ba0..beaf3ba22 100644
--- a/moli-renderer-v8/src/document_runtime/lifecycle.rs
+++ b/moli-renderer-v8/src/document_runtime/lifecycle.rs
@@ -286,9 +286,7 @@ impl DocumentRuntime {
self.document_write_script_preload_scanner = None;
self.main_document_script_preloads = Default::default();
self.document_write_script_preloads.clear();
- self.pending_document_write_external_script_load = None;
- self.pending_document_write_stylesheet_blocked_script = None;
- self.pending_document_write_stylesheet_parser_pause = None;
+ self.pending_parser_blocking_work = None;
self.root_document_parser = None;
self.delivered_meta_content_security_policies
.get_mut()
diff --git a/moli-renderer-v8/src/document_runtime/parser_blocking.rs b/moli-renderer-v8/src/document_runtime/parser_blocking.rs
new file mode 100644
index 000000000..8c8661db7
--- /dev/null
+++ b/moli-renderer-v8/src/document_runtime/parser_blocking.rs
@@ -0,0 +1,94 @@
+use super::*;
+use crate::parser_script::main_document::PendingMainParserScript;
+
+/// The Document owns one pending parser blocker, including synchronous input
+/// inserted by document.write(). Executing work is taken out of this slot
+/// before calling JavaScript: reentry may install its own blocker here.
+#[derive(Debug)]
+pub(super) enum PendingParserBlockingWork {
+ MainScript(Box<PendingMainParserScript>),
+ Insertion(Box<PendingParserInsertion>),
+}
+
+#[derive(Debug)]
+pub(super) struct PendingParserInsertion {
+ pub(super) insertion: SuspendedDocumentWriteInsertion,
+ pub(super) blocking_signatures: HashSet<DocumentBlockingStylesheetSignature>,
+ pub(super) work: ParserInsertionWork,
+ pub(super) resume_after_completion: VecDeque<SuspendedDocumentWriteContinuation>,
+}
+
+#[derive(Debug)]
+pub(super) enum ParserInsertionWork {
+ StylesheetBoundary,
+ Script {
+ node: DomHandle,
+ start_line: u64,
+ start_column: u64,
+ script: PreparedScript,
+ },
+ ExternalScript {
+ target: crate::types::DocumentWriteExternalScriptFetchTarget,
+ start: DocumentWriteExternalScriptStart,
+ ready_completion: Option<Box<crate::types::DocumentWriteExternalScriptLoadCompletion>>,
+ },
+}
+
+impl DocumentRuntime {
+ pub(crate) fn pending_main_parser_script(&self) -> Option<&PendingMainParserScript> {
+ match self.pending_parser_blocking_work.as_ref()? {
+ PendingParserBlockingWork::MainScript(script) => Some(script),
+ PendingParserBlockingWork::Insertion(_) => None,
+ }
+ }
+
+ pub(crate) fn take_pending_main_parser_script(&mut self) -> Option<PendingMainParserScript> {
+ self.pending_main_parser_script()?;
+ let Some(PendingParserBlockingWork::MainScript(script)) =
+ self.pending_parser_blocking_work.take()
+ else {
+ unreachable!()
+ };
+ Some(*script)
+ }
+
+ pub(crate) fn install_pending_main_parser_script(&mut self, script: PendingMainParserScript) {
+ self.install_parser_blocking_work(PendingParserBlockingWork::MainScript(Box::new(script)));
+ }
+
+ fn install_parser_blocking_work(&mut self, work: PendingParserBlockingWork) {
+ assert!(
+ self.pending_parser_blocking_work.is_none(),
+ "take the current parser blocker before installing another one"
+ );
+ self.pending_parser_blocking_work = Some(work);
+ }
+
+ pub(super) fn pending_parser_insertion(&self) -> Option<&PendingParserInsertion> {
+ match self.pending_parser_blocking_work.as_ref()? {
+ PendingParserBlockingWork::Insertion(pending) => Some(pending),
+ PendingParserBlockingWork::MainScript(_) => None,
+ }
+ }
+
+ pub(super) fn pending_parser_insertion_mut(&mut self) -> Option<&mut PendingParserInsertion> {
+ match self.pending_parser_blocking_work.as_mut()? {
+ PendingParserBlockingWork::Insertion(pending) => Some(pending),
+ PendingParserBlockingWork::MainScript(_) => None,
+ }
+ }
+
+ pub(super) fn take_pending_parser_insertion(&mut self) -> Option<PendingParserInsertion> {
+ self.pending_parser_insertion()?;
+ let Some(PendingParserBlockingWork::Insertion(pending)) =
+ self.pending_parser_blocking_work.take()
+ else {
+ unreachable!()
+ };
+ Some(*pending)
+ }
+
+ pub(super) fn install_pending_parser_insertion(&mut self, pending: PendingParserInsertion) {
+ self.install_parser_blocking_work(PendingParserBlockingWork::Insertion(Box::new(pending)));
+ }
+}
diff --git a/moli-renderer-v8/src/document_runtime/runtime_core.rs b/moli-renderer-v8/src/document_runtime/runtime_core.rs
index be7e9c873..c189211b8 100644
--- a/moli-renderer-v8/src/document_runtime/runtime_core.rs
+++ b/moli-renderer-v8/src/document_runtime/runtime_core.rs
@@ -123,9 +123,7 @@ impl DocumentRuntime {
document_write_script_preload_scanner: None,
main_document_script_preloads: Default::default(),
document_write_script_preloads: HashMap::new(),
- pending_document_write_external_script_load: None,
- pending_document_write_stylesheet_blocked_script: None,
- pending_document_write_stylesheet_parser_pause: None,
+ pending_parser_blocking_work: None,
}
}
@@ -246,9 +244,7 @@ impl DocumentRuntime {
document_write_script_preload_scanner: _,
main_document_script_preloads: _,
document_write_script_preloads: _,
- pending_document_write_external_script_load: _,
- pending_document_write_stylesheet_blocked_script: _,
- pending_document_write_stylesheet_parser_pause: _,
+ pending_parser_blocking_work: _,
} = self;
dom_host.into_dom_host()
}
diff --git a/moli-renderer-v8/src/parser_script/action.rs b/moli-renderer-v8/src/parser_script/action.rs
index 1a29f80ec..8e1029e6d 100644
--- a/moli-renderer-v8/src/parser_script/action.rs
+++ b/moli-renderer-v8/src/parser_script/action.rs
@@ -457,21 +457,6 @@ impl<Target> ParserClassicScriptSourceLoadCompletionAction<Target> {
}
}
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct ParserPendingClassicScriptSourceLoadWaitAction<SourceLoadWait> {
- source_load_wait: Option<SourceLoadWait>,
-}
-
-impl<SourceLoadWait> ParserPendingClassicScriptSourceLoadWaitAction<SourceLoadWait> {
- pub(crate) fn new(source_load_wait: Option<SourceLoadWait>) -> Self {
- Self { source_load_wait }
- }
-
- pub(crate) fn into_source_load_wait(self) -> Option<SourceLoadWait> {
- self.source_load_wait
- }
-}
-
pub(crate) struct ParserPendingClassicScriptSourceResultAction<'a> {
notification: ParserPendingClassicScriptNotification,
network_result: Option<&'a SharedNavigationResponseResult>,
diff --git a/moli-renderer-v8/src/parser_script/context.rs b/moli-renderer-v8/src/parser_script/context.rs
index 76b66cd94..2f09227ee 100644
--- a/moli-renderer-v8/src/parser_script/context.rs
+++ b/moli-renderer-v8/src/parser_script/context.rs
@@ -51,9 +51,3 @@ pub(crate) trait ParserClassicScriptSourceLoadCompletionState {
fn parser_classic_source_load_owner(&self) -> Option<Self::SourceLoadOwner>;
}
-
-pub(crate) trait ParserClassicScriptSourceLoadWaitState {
- type SourceLoadWait;
-
- fn parser_classic_source_load_wait(&self) -> Option<Self::SourceLoadWait>;
-}
diff --git a/moli-renderer-v8/src/parser_script/main_document.rs b/moli-renderer-v8/src/parser_script/main_document.rs
new file mode 100644
index 000000000..dcb6ebee8
--- /dev/null
+++ b/moli-renderer-v8/src/parser_script/main_document.rs
@@ -0,0 +1,105 @@
+use std::collections::HashSet;
+
+use crate::DocumentBlockingStylesheetSignature;
+use crate::frame_owner_model::FrameDocumentTaskOwner;
+use crate::live_document_parser::ParserResumePermit;
+use crate::parser_script::context::{
+ ParserClassicScriptDocumentOwnerState, ParserClassicScriptExecutionGateState,
+ ParserClassicScriptSourceLoadOutcomeState, ParserClassicScriptSourceLoadStartState,
+ ParserClassicScriptSourceLoadState, ParserClassicScriptSourceResultState,
+};
+use crate::parser_script::item::ParserClassicScriptRunnerItem;
+use crate::planning::SharedScriptSourceLoad;
+
+pub(crate) type PendingMainParserScript =
+ ParserClassicScriptRunnerItem<PendingParsingBlockingClassicScriptContext>;
+
+#[derive(Debug, Clone)]
+pub(crate) struct PendingParsingBlockingClassicScriptContext {
+ owner: FrameDocumentTaskOwner,
+ pub(crate) blocking_signatures_before: HashSet<DocumentBlockingStylesheetSignature>,
+ pub(crate) source_load: Option<PendingParserBlockingSourceLoad>,
+ resume_permit: Option<ParserResumePermit>,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum PendingParserBlockingSourceLoad {
+ ReusablePreload(SharedScriptSourceLoad),
+ ParserDiscovered(SharedScriptSourceLoad),
+}
+
+impl PendingParserBlockingSourceLoad {
+ pub(crate) fn shared_load(&self) -> SharedScriptSourceLoad {
+ match self {
+ Self::ReusablePreload(load) | Self::ParserDiscovered(load) => load.clone(),
+ }
+ }
+}
+
+impl PendingParsingBlockingClassicScriptContext {
+ pub(crate) fn new(
+ owner: FrameDocumentTaskOwner,
+ blocking_signatures_before: HashSet<DocumentBlockingStylesheetSignature>,
+ source_load: Option<PendingParserBlockingSourceLoad>,
+ ) -> Self {
+ Self {
+ owner,
+ blocking_signatures_before,
+ source_load,
+ resume_permit: None,
+ }
+ }
+
+ pub(crate) fn install_resume_permit(&mut self, permit: ParserResumePermit) {
+ assert!(
+ self.resume_permit.replace(permit).is_none(),
+ "one parser-blocking script context can own only one parser resume permit"
+ );
+ }
+
+ pub(crate) fn resume_permit(&self) -> Option<ParserResumePermit> {
+ self.resume_permit
+ }
+}
+
+impl ParserClassicScriptDocumentOwnerState for PendingParsingBlockingClassicScriptContext {
+ fn parser_classic_document_task_owner(&self) -> FrameDocumentTaskOwner {
+ self.owner
+ }
+}
+
+impl ParserClassicScriptExecutionGateState for PendingParsingBlockingClassicScriptContext {
+ type ExecutionGateState = HashSet<DocumentBlockingStylesheetSignature>;
+
+ fn parser_classic_execution_gate_state(&self) -> Self::ExecutionGateState {
+ self.blocking_signatures_before.clone()
+ }
+}
+
+impl ParserClassicScriptSourceLoadState for PendingParsingBlockingClassicScriptContext {
+ fn clear_parser_classic_source_load_state(&mut self) {
+ self.source_load = None;
+ }
+}
+
+impl ParserClassicScriptSourceResultState for PendingParsingBlockingClassicScriptContext {
+ fn parser_classic_source_load_outcome_state(
+ &self,
+ ) -> ParserClassicScriptSourceLoadOutcomeState {
+ let Some(source_load) = self.source_load.as_ref() else {
+ return ParserClassicScriptSourceLoadOutcomeState::NoSourceLoad;
+ };
+ let Some(outcome) = source_load.shared_load().try_outcome() else {
+ return ParserClassicScriptSourceLoadOutcomeState::Waiting;
+ };
+ ParserClassicScriptSourceLoadOutcomeState::Ready(outcome)
+ }
+}
+
+impl ParserClassicScriptSourceLoadStartState for PendingParsingBlockingClassicScriptContext {
+ type SourceLoadState = PendingParserBlockingSourceLoad;
+
+ fn install_parser_classic_source_load_state(&mut self, state: Self::SourceLoadState) {
+ self.source_load = Some(state);
+ }
+}
diff --git a/moli-renderer-v8/src/parser_script/mod.rs b/moli-renderer-v8/src/parser_script/mod.rs
index 0aa69309f..43576726d 100644
--- a/moli-renderer-v8/src/parser_script/mod.rs
+++ b/moli-renderer-v8/src/parser_script/mod.rs
@@ -1,6 +1,7 @@
pub(crate) mod action;
pub(crate) mod context;
pub(crate) mod item;
+pub(crate) mod main_document;
pub(crate) mod owner;
pub(crate) mod payload;
pub(crate) mod pending;
diff --git a/moli-renderer-v8/src/parser_script/owner.rs b/moli-renderer-v8/src/parser_script/owner.rs
index 3956c1beb..6b04ad0ea 100644
--- a/moli-renderer-v8/src/parser_script/owner.rs
+++ b/moli-renderer-v8/src/parser_script/owner.rs
@@ -11,11 +11,11 @@ use crate::parser_script::action::{
ParserPendingClassicScriptSourceLoadCandidate,
ParserPendingClassicScriptSourceLoadClientAction,
ParserPendingClassicScriptSourceLoadCompletionAction,
- ParserPendingClassicScriptSourceLoadWaitAction, ParserPendingClassicScriptSourceResultAction,
+ ParserPendingClassicScriptSourceResultAction,
};
use crate::parser_script::context::{
ParserClassicScriptExecutionGateState, ParserClassicScriptSourceLoadCompletionState,
- ParserClassicScriptSourceLoadStartState, ParserClassicScriptSourceLoadWaitState,
+ ParserClassicScriptSourceLoadStartState,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -158,19 +158,6 @@ where
) -> Option<Self::SourceLoadCompletionAction>;
}
-pub(crate) trait ParserScriptSourceLoadWaitOwner<Context>:
- ParserScriptOwner<Context>
-where
- Context: ParserClassicScriptExecutionGateState + ParserClassicScriptSourceLoadWaitState,
-{
- type SourceLoadWaitAction;
-
- fn parser_script_source_load_wait_action(
- &mut self,
- action: ParserPendingClassicScriptSourceLoadWaitAction<Context::SourceLoadWait>,
- ) -> Option<Self::SourceLoadWaitAction>;
-}
-
pub(crate) trait ParserScriptSourceResultOwner<Context>: ParserScriptOwner<Context>
where
Context: ParserClassicScriptExecutionGateState,
diff --git a/moli-renderer-v8/src/parser_script/queue.rs b/moli-renderer-v8/src/parser_script/queue.rs
index 02940e7bb..54a5faaf7 100644
--- a/moli-renderer-v8/src/parser_script/queue.rs
+++ b/moli-renderer-v8/src/parser_script/queue.rs
@@ -36,16 +36,14 @@ impl<C> ParserClassicScriptRunnerQueue<C> {
self.scripts.push(script);
}
- pub(crate) fn has_current(&self) -> bool {
- self.scripts.current().is_some()
- }
-
- pub(crate) fn install_current(&mut self, script: ParserClassicScriptRunnerItem<C>) {
- self.scripts.install_current(script);
+ pub(crate) fn finish_current(&mut self) {
+ self.scripts.finish_current();
}
- pub(crate) fn finish_current(&mut self) {
+ pub(crate) fn take_current(&mut self) -> Option<ParserClassicScriptRunnerItem<C>> {
+ let script = self.scripts.current.take()?;
self.scripts.finish_current();
+ Some(script)
}
#[cfg(test)]
@@ -134,10 +132,6 @@ impl<T> ParserBlockingClassicScriptQueue<T> {
}
}
- fn install_current(&mut self, script: T) {
- self.current = Some(script);
- }
-
#[cfg(test)]
fn is_empty(&self) -> bool {
self.current.is_none() && self.queued_after_current.is_empty()
diff --git a/moli-renderer-v8/src/parser_script/runner.rs b/moli-renderer-v8/src/parser_script/runner.rs
index 90c7c5d58..2cf1f0c2b 100644
--- a/moli-renderer-v8/src/parser_script/runner.rs
+++ b/moli-renderer-v8/src/parser_script/runner.rs
@@ -8,14 +8,12 @@ use crate::parser_script::action::{
ParserPendingClassicScriptSourceLoadClientAction,
ParserPendingClassicScriptSourceLoadCompletionAction,
ParserPendingClassicScriptSourceLoadCompletionRecord,
- ParserPendingClassicScriptSourceLoadRequest, ParserPendingClassicScriptSourceLoadWaitAction,
- ParserPendingClassicScriptSourceResultAction,
+ ParserPendingClassicScriptSourceLoadRequest, ParserPendingClassicScriptSourceResultAction,
};
use crate::parser_script::context::{
ParserClassicScriptExecutionGateState, ParserClassicScriptSourceLoadCompletionState,
ParserClassicScriptSourceLoadOutcomeState, ParserClassicScriptSourceLoadStartState,
- ParserClassicScriptSourceLoadState, ParserClassicScriptSourceLoadWaitState,
- ParserClassicScriptSourceResultState,
+ ParserClassicScriptSourceLoadState, ParserClassicScriptSourceResultState,
};
use crate::parser_script::item::ParserClassicScriptRunnerItem;
use crate::parser_script::owner::{
@@ -23,7 +21,7 @@ use crate::parser_script::owner::{
ParserScriptDisposeReadyOwner, ParserScriptExecutionGate, ParserScriptFinishExecutionOwner,
ParserScriptOwner, ParserScriptReadyOwner, ParserScriptSourceFailureOwner,
ParserScriptSourceLoadClientOwner, ParserScriptSourceLoadCompletionOwner,
- ParserScriptSourceLoadWaitOwner, ParserScriptSourceResultOwner,
+ ParserScriptSourceResultOwner,
};
#[cfg(test)]
use crate::parser_script::payload::{
@@ -35,9 +33,8 @@ use crate::parser_script::payload::{
#[cfg(test)]
use crate::parser_script::pending::ParserPendingClassicScriptEntry;
use crate::parser_script::projection::{
- ParserClassicScriptBlockedOnExecution, ParserClassicScriptBlockedOnSourceLoad,
- ParserClassicScriptExecutionGateProjection, ParserClassicScriptNextActionWithBlockedScript,
- ParserClassicScriptSourceResultApplication,
+ ParserClassicScriptBlockedOnExecution, ParserClassicScriptExecutionGateProjection,
+ ParserClassicScriptNextActionWithBlockedScript, ParserClassicScriptSourceResultApplication,
};
use crate::parser_script::queue::ParserClassicScriptRunnerQueue;
#[cfg(test)]
@@ -97,8 +94,10 @@ where
Some(action)
}
- pub(crate) fn has_parser_blocking_script(&self) -> bool {
- self.parser_blocking_scripts.has_current()
+ pub(crate) fn take_current_parser_blocking_script(
+ &mut self,
+ ) -> Option<ParserClassicScriptRunnerItem<C>> {
+ self.parser_blocking_scripts.take_current()
}
pub(crate) fn current_parser_blocking_context(&self) -> Option<&C> {
@@ -129,33 +128,6 @@ where
.map(|metadata| metadata.script_handle())
}
- pub(crate) fn install_parser_blocking_script_blocked_on_execution(
- &mut self,
- blocked: ParserClassicScriptBlockedOnExecution<C>,
- ) {
- self.parser_blocking_scripts
- .install_current(blocked.into_script());
- }
-
- pub(crate) fn install_parser_blocking_script_blocked_on_source_load(
- &mut self,
- blocked: ParserClassicScriptBlockedOnSourceLoad<C>,
- ) {
- self.parser_blocking_scripts
- .install_current(blocked.into_script());
- }
-
- pub(crate) fn discard_current_parser_blocking_script_if_handle(
- &mut self,
- script_handle: DomHandle,
- ) -> bool {
- if self.current_parser_blocking_script_handle() != Some(script_handle) {
- return false;
- }
- self.parser_blocking_scripts.finish_current();
- true
- }
-
pub(crate) fn discard_current_deferred_script_if_handle(
&mut self,
script_handle: DomHandle,
@@ -291,24 +263,6 @@ where
})
}
- pub(crate) fn current_parser_blocking_source_load_wait_action_with_owner<Owner>(
- &self,
- owner: &mut Owner,
- ) -> Option<Owner::SourceLoadWaitAction>
- where
- C: ParserClassicScriptSourceLoadWaitState,
- Owner: ParserScriptSourceLoadWaitOwner<C>,
- {
- let script = self.current_parser_blocking_script()?;
- if !owner.is_current_parser_script_owner(script.context()) {
- return None;
- }
- let action = ParserPendingClassicScriptSourceLoadWaitAction::new(
- script.context().parser_classic_source_load_wait(),
- );
- owner.parser_script_source_load_wait_action(action)
- }
-
pub(crate) fn take_current_parser_blocking_next_action_with_owner<Owner, Action>(
&mut self,
owner: &mut Owner,
@@ -994,7 +948,7 @@ mod tests {
}
#[test]
- fn parser_script_runner_discards_current_only_when_handle_still_matches() {
+ fn parser_script_runner_takes_current_without_removing_following_work() {
let first_script_handle = DomHandle::new(11);
let second_script_handle = DomHandle::new(12);
let mut runner = ParserClassicScriptRunner::new_parser_blocking(vec![
@@ -1022,21 +976,25 @@ mod tests {
runner.current_parser_blocking_script_handle(),
Some(first_script_handle)
);
- assert!(
- runner.discard_current_parser_blocking_script_if_handle(first_script_handle),
- "first pending script should be discarded when it is still current"
+ let first = runner.take_current_parser_blocking_script().unwrap();
+ assert_eq!(
+ first.runner_metadata().unwrap().script_handle(),
+ first_script_handle
);
assert_eq!(
runner.current_parser_blocking_script_handle(),
Some(second_script_handle)
);
- assert!(
- !runner.discard_current_parser_blocking_script_if_handle(first_script_handle),
- "stale handle must not discard the next pending script"
- );
+ drop(first);
assert_eq!(
runner.current_parser_blocking_script_handle(),
Some(second_script_handle)
);
+ let second = runner.take_current_parser_blocking_script().unwrap();
+ assert_eq!(
+ second.runner_metadata().unwrap().script_handle(),
+ second_script_handle
+ );
+ assert!(runner.take_current_parser_blocking_script().is_none());
}
}
diff --git a/moli-renderer-v8/src/runtime/phase_one/document_write_resource_tests.rs b/moli-renderer-v8/src/runtime/phase_one/document_write_resource_tests.rs
index 394b0f400..ba9f5a919 100644
--- a/moli-renderer-v8/src/runtime/phase_one/document_write_resource_tests.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/document_write_resource_tests.rs
@@ -650,6 +650,196 @@ async fn evaluate_pending_on_owner_local_task(
.expect("pending document.write result should evaluate")
}
+async fn spawn_gated_parser_resource(
+ content_type: &'static str,
+ body: &'static str,
+) -> (Url, tokio::sync::oneshot::Sender<()>, JoinHandle<()>) {
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let address = listener.local_addr().unwrap();
+ let (release, released) = tokio::sync::oneshot::channel();
+ let server = tokio::spawn(async move {
+ let (mut stream, _) = listener.accept().await.unwrap();
+ let mut request = vec![0; 4096];
+ let read = stream.read(&mut request).await.unwrap();
+ assert!(String::from_utf8_lossy(&request[..read]).starts_with("GET /resource "));
+ released.await.expect("release parser resource");
+ let response = format!(
+ "HTTP/1.1 200 OK\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
+ body.len(),
+ );
+ stream.write_all(response.as_bytes()).await.unwrap();
+ stream.shutdown().await.unwrap();
+ });
+ (
+ Url::parse(&format!("http://{address}/resource")).unwrap(),
+ release,
+ server,
+ )
+}
+
+fn retain_pending_parser_page(
+ outcome: ParseTimePageVmCreationOutcome,
+ owner_wake_rx: tokio::sync::mpsc::UnboundedReceiver<crate::page_task_queue::RendererOwnerWake>,
+) -> PendingStandaloneDocumentWritePage {
+ let ParseTimePageVmCreationOutcome::PendingPhaseOne(
+ PendingPhaseOneResidence::ClosedInputPageWork { runtime, started },
+ ) = outcome
+ else {
+ panic!("the remaining resource must keep the parser suspended");
+ };
+ PendingStandaloneDocumentWritePage {
+ runtime,
+ started,
+ owner_wake_rx,
+ }
+}
+
+async fn resume_after_stylesheet_completion(
+ mut pending: PendingStandaloneDocumentWritePage,
+) -> (
+ ParseTimePageVmCreationOutcome,
+ tokio::sync::mpsc::UnboundedReceiver<crate::page_task_queue::RendererOwnerWake>,
+) {
+ tokio::time::timeout(
+ std::time::Duration::from_secs(5),
+ wait_for_standalone_stylesheet_completion(&mut pending),
+ )
+ .await
+ .expect("stylesheet completion");
+ let pending = run_standalone_selected_page_task(
+ pending,
+ crate::runtime::page_vm::PageSelectedTaskTestSelector::StylesheetCompletion,
+ )
+ .await;
+ let PendingStandaloneDocumentWritePage {
+ runtime,
+ started,
+ owner_wake_rx,
+ } = pending;
+ resume_standalone_main_parser_continuation_if_ready(
+ ParseTimePageVmCreationOutcome::PendingPhaseOne(
+ PendingPhaseOneResidence::ClosedInputPageWork { runtime, started },
+ ),
+ owner_wake_rx,
+ )
+ .await
+}
+
+#[test]
+fn document_write_source_before_stylesheet_executes_once_after_both_are_ready() {
+ assert_parser_insertion_resource_order(true);
+}
+
+#[test]
+fn document_write_stylesheet_before_source_executes_once_after_both_are_ready() {
+ assert_parser_insertion_resource_order(false);
+}
+
+fn assert_parser_insertion_resource_order(source_first: bool) {
+ super::tests::run_phase_one_large_stack_test("parser-insertion-resource-order", move || {
+ let runtime = tokio::runtime::Builder::new_current_thread()
+ .enable_all()
+ .build()
+ .unwrap();
+ runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
+ let _js_runtime = crate::JsRuntime::initialize();
+ let (css, release_css, css_server) = spawn_gated_parser_resource(
+ "text/css", "html { color: rgb(1, 2, 3); }",
+ ).await;
+ let (js, release_js, js_server) = spawn_gated_parser_resource(
+ "text/javascript", "events.push('external'); globalThis.tailAtScript = !!document.getElementById('tail');",
+ ).await;
+ let mut release_css = Some(release_css);
+ let mut release_js = Some(release_js);
+ let html = format!(r#"<!doctype html><html><head><script>
+globalThis.events = [];
+document.write(`<link rel="stylesheet" href="{css}"><script src="{js}" onload="events.push('load')"><\/script><span id="written">written</span>`);
+events.push('outer');
+</script></head><body><p id="tail">tail</p></body></html>"#);
+ let pending = start_standalone_document_write_page(html, css.join("page.html").unwrap()).await;
+ let (outcome, wake) = if source_first {
+ release_js.take().unwrap().send(()).unwrap();
+ resume_standalone_document_write_page(pending).await
+ } else {
+ release_css.take().unwrap().send(()).unwrap();
+ resume_after_stylesheet_completion(pending).await
+ };
+ let pending = retain_pending_parser_page(outcome, wake);
+ let (pending, result) = evaluate_pending_on_owner_local_task(pending,
+ "JSON.stringify({events, tail: !!document.getElementById('tail'), written: !!document.getElementById('written')})",
+ ).await;
+ assert_eq!(result["value"], r#"{"events":["outer"],"tail":false,"written":false}"#);
+ let (outcome, wake) = if source_first {
+ release_css.take().unwrap().send(()).unwrap();
+ resume_after_stylesheet_completion(pending).await
+ } else {
+ release_js.take().unwrap().send(()).unwrap();
+ resume_standalone_document_write_page(pending).await
+ };
+ let (outcome, _) = resume_standalone_main_parser_continuation_if_ready(outcome, wake).await;
+ let ParseTimePageVmCreationOutcome::ContinuePhaseTwo { page_vm, .. } = outcome else {
+ panic!("both resources must release the same parser blocker");
+ };
+ let result = evaluate_on_owner_local_task(page_vm,
+ "JSON.stringify({events, tailAtScript, tail: !!document.getElementById('tail'), written: !!document.getElementById('written')})",
+ ).await;
+ assert_eq!(result["value"], r#"{"events":["outer","external","load"],"tailAtScript":false,"tail":true,"written":true}"#);
+ css_server.await.unwrap();
+ js_server.await.unwrap();
+ }));
+ });
+}
+
+#[test]
+fn resumed_main_parser_script_preserves_the_blocker_installed_by_its_nested_write() {
+ super::tests::run_phase_one_large_stack_test("main-parser-reentrant-blocker", || {
+ let runtime = tokio::runtime::Builder::new_current_thread()
+ .enable_all()
+ .build()
+ .unwrap();
+ runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
+ let _js_runtime = crate::JsRuntime::initialize();
+ let (css, release_css, css_server) = spawn_gated_parser_resource(
+ "text/css", "html { color: rgb(1, 2, 3); }",
+ ).await;
+ let (js, release_js, js_server) = spawn_gated_parser_resource(
+ "text/javascript", "events.push('inner');",
+ ).await;
+ let html = format!(r#"<!doctype html><html><head><link rel="stylesheet" href="{css}"><script>
+globalThis.events = ['outer-before'];
+document.write(`<script src="{js}"><\/script><span id="written">written</span>`);
+events.push('outer-after');
+</script></head><body><p id="tail">tail</p></body></html>"#);
+ let pending = start_standalone_parser_page(
+ PageId::new_for_testing(903), html, css.join("page.html").unwrap(),
+ ).await;
+ assert!(pending.runtime.page_vm.vm().document_runtime.pending_main_parser_script().is_some());
+ release_css.send(()).unwrap();
+ let (outcome, wake) = resume_after_stylesheet_completion(pending).await;
+ let pending = retain_pending_parser_page(outcome, wake);
+ let document = &pending.runtime.page_vm.vm().document_runtime;
+ assert!(document.pending_main_parser_script().is_none());
+ assert!(document.has_pending_document_write_external_script_load());
+ let (pending, result) = evaluate_pending_on_owner_local_task(pending,
+ "JSON.stringify({events, tail: !!document.getElementById('tail'), written: !!document.getElementById('written')})",
+ ).await;
+ assert_eq!(result["value"], r#"{"events":["outer-before","outer-after"],"tail":false,"written":false}"#);
+ release_js.send(()).unwrap();
+ let (outcome, wake) = resume_standalone_document_write_page(pending).await;
+ let (outcome, _) = resume_standalone_main_parser_continuation_if_ready(outcome, wake).await;
+ let ParseTimePageVmCreationOutcome::ContinuePhaseTwo { page_vm, .. } = outcome else {
+ panic!("the nested blocker must retain its own continuation");
+ };
+ let result = evaluate_on_owner_local_task(page_vm,
+ "JSON.stringify({events, tail: !!document.getElementById('tail'), written: !!document.getElementById('written')})",
+ ).await;
+ assert_eq!(result["value"], r#"{"events":["outer-before","outer-after","inner"],"tail":true,"written":true}"#);
+ css_server.await.unwrap();
+ js_server.await.unwrap();
+ }));
+ });
+}
+
#[test]
fn parser_driver_retains_stylesheet_suspension_until_its_continuation() {
assert_stylesheet_suspension_resume_owner(ParserResumeOwner::ParserDriver);
diff --git a/moli-renderer-v8/src/runtime/phase_one/mod.rs b/moli-renderer-v8/src/runtime/phase_one/mod.rs
index fafe582ac..58a88c5ff 100644
--- a/moli-renderer-v8/src/runtime/phase_one/mod.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/mod.rs
@@ -60,6 +60,7 @@ use self::page_task_turn::{
execute_page_owned_document_script_turn_on_local_task,
execute_page_owned_work_turn_on_local_task,
};
+#[cfg(test)]
use self::parser_blocking_pending::PendingParsingBlockingClassicScriptRunner;
#[cfg(test)]
use self::parser_blocking_pending::{
@@ -453,7 +454,7 @@ mod tests {
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -3517,7 +3518,6 @@ document.body.setAttribute('data-error-state', [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -3635,7 +3635,6 @@ document.body.setAttribute('data-error-state', [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -3683,7 +3682,6 @@ document.body.setAttribute('data-error-state', [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -4459,7 +4457,6 @@ document.body.setAttribute('data-error-state', [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -4928,7 +4925,6 @@ document.body.setAttribute('data-error-state', [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -5004,7 +5000,6 @@ document.body.setAttribute('data-error-state', [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -5079,7 +5074,6 @@ queueMicrotask(() => window.__mainParserClassicCheckpointEvents.push('script-mic
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -5154,7 +5148,6 @@ queueMicrotask(() => window.__mainParserClassicCheckpointEvents.push('script-mic
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -5338,7 +5331,6 @@ queueMicrotask(() => window.__mainParserClassicCheckpointEvents.push('script-mic
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -5457,7 +5449,6 @@ queueMicrotask(() => window.__mainParserClassicCheckpointEvents.push('script-mic
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -5523,7 +5514,6 @@ queueMicrotask(() => window.__mainParserClassicCheckpointEvents.push('script-mic
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -5612,7 +5602,6 @@ queueMicrotask(() => window.__mainParserClassicCheckpointEvents.push('script-mic
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -5636,9 +5625,7 @@ queueMicrotask(() => window.__mainParserClassicCheckpointEvents.push('script-mic
.context_mut()
.blocking_signatures_before
.clear();
- driver
- .pending_parsing_blocking_script
- .install_parser_blocking_script_blocked_on_execution(*pending);
+ page_vm.vm_mut().document_runtime.install_pending_main_parser_script(pending.into_script());
stylesheet_release.notify_one();
let mut owner = ParseTimeOwner::Parser;
let mut parser_step_ready = true;
@@ -5736,7 +5723,6 @@ queueMicrotask(() => window.__mainParserClassicCheckpointEvents.push('script-mic
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -5814,7 +5800,6 @@ queueMicrotask(() => window.__mainParserClassicCheckpointEvents.push('script-mic
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -6065,7 +6050,6 @@ globalThis.__outerContinued = true;
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -6197,7 +6181,6 @@ globalThis.__outerContinued = true;
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -6255,7 +6238,6 @@ globalThis.__outerContinued = true;
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -6323,7 +6305,6 @@ globalThis.__outerContinued = true;
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -6398,9 +6379,11 @@ globalThis.__outerContinued = true;
assert_eq!(progress, OwnerStepProgress::Continue);
assert_eq!(owner, ParseTimeOwner::Document);
assert!(
- !state
- .pending_parsing_blocking_script
- .has_parser_blocking_script(),
+ page_vm
+ .vm()
+ .document_runtime
+ .pending_main_parser_script()
+ .is_none(),
"initial parser boundary should not invent a pending parser-blocking script"
);
assert!(
@@ -6527,7 +6510,6 @@ globalThis.__outerContinued = true;
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -6583,7 +6565,6 @@ globalThis.__outerContinued = true;
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -6647,7 +6628,6 @@ globalThis.__outerContinued = true;
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -14206,7 +14186,6 @@ document.body.append(window.jsRemovedLazyMedia, window.parserRemovedLazyMedia);
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -14287,7 +14266,6 @@ document.body.setAttribute('data-result', `${before}|${style.color}`);
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -14385,7 +14363,6 @@ document.body.setAttribute('data-result', `${before}|${style.color}`);
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -14504,7 +14481,6 @@ document.body.setAttribute('data-result', [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -14720,7 +14696,7 @@ document.body.setAttribute('data-result', [
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -14887,7 +14863,7 @@ document.body.setAttribute('data-result', [
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -15129,7 +15105,7 @@ document.body.setAttribute('data-result', [
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -15340,7 +15316,7 @@ document.body.setAttribute('data-result', [
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -15506,7 +15482,7 @@ for (const [id, flag] of [
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -15582,7 +15558,7 @@ document.body.setAttribute('data-result', 'done');
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -15666,7 +15642,7 @@ document.body.setAttribute('data-result', [
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -15840,7 +15816,7 @@ document.body.setAttribute('data-parser-returned', [
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -16009,7 +15985,7 @@ document.body.setAttribute('data-idl-nonce', element.nonce);
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -16247,7 +16223,7 @@ document.body.setAttribute('data-input', [
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -16425,7 +16401,7 @@ document.body.setAttribute('data-face-disabled', String(face.matches(':disabled'
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -16539,7 +16515,7 @@ document.body.setAttribute('data-after-visible', String(!!document.getElementByI
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -16661,7 +16637,7 @@ document.body.setAttribute('data-after-body-visible', String(!!document.getEleme
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -16751,7 +16727,7 @@ document.body.setAttribute('data-token', instance.getAttribute('data-token') ||
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -16895,7 +16871,7 @@ document.body.setAttribute('data-bad-write', String(!!document.getElementById('b
scheduler: &mut state.scheduler,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
+
input_closed: &state.input_closed,
};
@@ -16955,7 +16931,6 @@ document.body.setAttribute("data-range", [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -17012,7 +16987,6 @@ document.body.setAttribute("data-range", [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -17113,7 +17087,6 @@ document.body.setAttribute("data-range", [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -17246,7 +17219,6 @@ document.body.setAttribute("data-range", [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -17368,7 +17340,6 @@ document.body.setAttribute("data-range", [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -17556,7 +17527,6 @@ document.body.setAttribute("data-range", [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -17679,7 +17649,6 @@ document.body.setAttribute("data-range", [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -17775,7 +17744,6 @@ document.body.setAttribute("data-range", [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -17883,7 +17851,6 @@ document.body.setAttribute("data-range", [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -18012,7 +17979,6 @@ document.body.setAttribute("data-range", [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -18124,7 +18090,6 @@ document.body.setAttribute("data-range", [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -18212,7 +18177,6 @@ document.body.setAttribute("data-range", [
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
diff --git a/moli-renderer-v8/src/runtime/phase_one/non_executable_script_tests.rs b/moli-renderer-v8/src/runtime/phase_one/non_executable_script_tests.rs
index 5918b51c0..442be09ac 100644
--- a/moli-renderer-v8/src/runtime/phase_one/non_executable_script_tests.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/non_executable_script_tests.rs
@@ -36,7 +36,6 @@ fn data_block_completes_in_parser_turn_without_page_task() {
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
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 c6d8568fa..f2650b7f9 100644
--- a/moli-renderer-v8/src/runtime/phase_one/owner_turn.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/owner_turn.rs
@@ -82,7 +82,6 @@ impl ConcurrentParseTimeRuntime {
final_url: &state.final_url,
parser_session: &mut state.parser_session,
scheduler: &mut state.scheduler,
- pending_parsing_blocking_script: &mut state.pending_parsing_blocking_script,
buffered_document_preloads: &mut state.buffered_document_preloads,
service_worker_preload_context: state.service_worker_preload_context.as_ref(),
input_closed: &state.input_closed,
@@ -102,9 +101,11 @@ impl ConcurrentParseTimeRuntime {
pending_parsing_blocking_wait,
PendingParsingBlockingWait::None,
);
- let has_pending_parsing_blocking_script = state
- .pending_parsing_blocking_script
- .has_parser_blocking_script();
+ let has_pending_parsing_blocking_script = page_vm
+ .vm()
+ .document_runtime
+ .pending_main_parser_script()
+ .is_some();
let mut context = DocumentTurnContext {
scheduler: &mut state.scheduler,
parser_session: &state.parser_session,
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 b52738147..8edeceb80 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
@@ -17,16 +17,15 @@ use crate::parser_script::action::{
ParserPendingClassicScriptFinishedExecutionAction, ParserPendingClassicScriptNotification,
ParserPendingClassicScriptReadyAction, ParserPendingClassicScriptSourceFailureAction,
ParserPendingClassicScriptSourceLoadAction, ParserPendingClassicScriptSourceLoadRequest,
- ParserPendingClassicScriptSourceLoadWaitAction, ParserPendingClassicScriptSourceResultAction,
+ ParserPendingClassicScriptSourceResultAction,
};
use crate::parser_script::context::ParserClassicScriptDocumentOwnerState;
use crate::parser_script::owner::{
ParserScriptBeginExecutionOwner, ParserScriptBeginSourceLoadOwner,
ParserScriptExecutionBlocker, ParserScriptExecutionGate, ParserScriptFinishExecutionOwner,
ParserScriptOwner, ParserScriptReadyOwner, ParserScriptSourceFailureOwner,
- ParserScriptSourceLoadWaitOwner, ParserScriptSourceResultOwner,
+ ParserScriptSourceResultOwner,
};
-use crate::planning::SharedScriptSourceLoad;
use crate::script_vm::ParserOwnedClassicScriptCompletion;
use std::collections::HashSet;
@@ -48,8 +47,6 @@ pub(super) struct MainParserBlockingBeginExecutionOwner {
pub(super) completion_target: MainDocumentClassicScriptTarget,
}
-pub(super) struct MainParserBlockingSourceLoadWaitOwner;
-
pub(super) struct MainParserBlockingLifecycleOwner {
target: MainDocumentClassicScriptTarget,
current_owner: Option<FrameDocumentTaskOwner>,
@@ -216,24 +213,6 @@ impl ParserScriptOwner<PendingParsingBlockingClassicScriptContext>
}
}
-impl ParserScriptOwner<PendingParsingBlockingClassicScriptContext>
- for MainParserBlockingSourceLoadWaitOwner
-{
-}
-
-impl ParserScriptSourceLoadWaitOwner<PendingParsingBlockingClassicScriptContext>
- for MainParserBlockingSourceLoadWaitOwner
-{
- type SourceLoadWaitAction = SharedScriptSourceLoad;
-
- fn parser_script_source_load_wait_action(
- &mut self,
- action: ParserPendingClassicScriptSourceLoadWaitAction<SharedScriptSourceLoad>,
- ) -> Option<Self::SourceLoadWaitAction> {
- action.into_source_load_wait()
- }
-}
-
impl ParserScriptOwner<PendingParsingBlockingClassicScriptContext>
for MainParserBlockingLifecycleOwner
{
diff --git a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_pending.rs b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_pending.rs
index b71da969b..222d5c1af 100644
--- a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_pending.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_pending.rs
@@ -1,21 +1,16 @@
use super::parser_blocking_owner::MainParserBlockingExternalLoadOwner;
use crate::DocumentBlockingStylesheetSignature;
use crate::frame_owner_model::FrameDocumentTaskOwner;
-use crate::live_document_parser::ParserResumePermit;
-use crate::parser_script::context::{
- ParserClassicScriptDocumentOwnerState, ParserClassicScriptExecutionGateState,
- ParserClassicScriptSourceLoadOutcomeState, ParserClassicScriptSourceLoadStartState,
- ParserClassicScriptSourceLoadState, ParserClassicScriptSourceLoadWaitState,
- ParserClassicScriptSourceResultState,
-};
use crate::parser_script::item::ParserClassicScriptRunnerItem;
+pub(super) use crate::parser_script::main_document::{
+ PendingParserBlockingSourceLoad, PendingParsingBlockingClassicScriptContext,
+};
#[cfg(test)]
use crate::parser_script::payload::ParserClassicScriptMetadata;
use crate::parser_script::payload::ParserPreparedClassicScript;
use crate::parser_script::runner::ParserClassicScriptRunner;
#[cfg(test)]
use crate::planning::PreparedScript;
-use crate::planning::SharedScriptSourceLoad;
use std::collections::HashSet;
pub(super) type PendingParsingBlockingClassicScript =
@@ -23,106 +18,6 @@ pub(super) type PendingParsingBlockingClassicScript =
pub(super) type PendingParsingBlockingClassicScriptRunner =
ParserClassicScriptRunner<PendingParsingBlockingClassicScriptContext>;
-#[derive(Debug, Clone)]
-pub(super) struct PendingParsingBlockingClassicScriptContext {
- owner: FrameDocumentTaskOwner,
- pub(super) blocking_signatures_before: HashSet<DocumentBlockingStylesheetSignature>,
- pub(super) source_load: Option<PendingParserBlockingSourceLoad>,
- resume_permit: Option<ParserResumePermit>,
-}
-
-#[derive(Debug, Clone)]
-pub(super) enum PendingParserBlockingSourceLoad {
- ReusablePreload(SharedScriptSourceLoad),
- ParserDiscovered(SharedScriptSourceLoad),
-}
-
-impl PendingParserBlockingSourceLoad {
- pub(super) fn shared_load(&self) -> SharedScriptSourceLoad {
- match self {
- Self::ReusablePreload(load) | Self::ParserDiscovered(load) => load.clone(),
- }
- }
-}
-
-impl PendingParsingBlockingClassicScriptContext {
- fn new(
- owner: FrameDocumentTaskOwner,
- blocking_signatures_before: HashSet<DocumentBlockingStylesheetSignature>,
- source_load: Option<PendingParserBlockingSourceLoad>,
- ) -> Self {
- Self {
- owner,
- blocking_signatures_before,
- source_load,
- resume_permit: None,
- }
- }
-
- pub(super) fn install_resume_permit(&mut self, permit: ParserResumePermit) {
- assert!(
- self.resume_permit.replace(permit).is_none(),
- "one parser-blocking script context can own only one parser resume permit"
- );
- }
-
- pub(super) fn resume_permit(&self) -> Option<ParserResumePermit> {
- self.resume_permit
- }
-}
-
-impl ParserClassicScriptDocumentOwnerState for PendingParsingBlockingClassicScriptContext {
- fn parser_classic_document_task_owner(&self) -> FrameDocumentTaskOwner {
- self.owner
- }
-}
-
-impl ParserClassicScriptExecutionGateState for PendingParsingBlockingClassicScriptContext {
- type ExecutionGateState = HashSet<DocumentBlockingStylesheetSignature>;
-
- fn parser_classic_execution_gate_state(&self) -> Self::ExecutionGateState {
- self.blocking_signatures_before.clone()
- }
-}
-
-impl ParserClassicScriptSourceLoadState for PendingParsingBlockingClassicScriptContext {
- fn clear_parser_classic_source_load_state(&mut self) {
- self.source_load = None;
- }
-}
-
-impl ParserClassicScriptSourceResultState for PendingParsingBlockingClassicScriptContext {
- fn parser_classic_source_load_outcome_state(
- &self,
- ) -> ParserClassicScriptSourceLoadOutcomeState {
- let Some(source_load) = self.source_load.as_ref() else {
- return ParserClassicScriptSourceLoadOutcomeState::NoSourceLoad;
- };
- let Some(outcome) = source_load.shared_load().try_outcome() else {
- return ParserClassicScriptSourceLoadOutcomeState::Waiting;
- };
- ParserClassicScriptSourceLoadOutcomeState::Ready(outcome)
- }
-}
-
-impl ParserClassicScriptSourceLoadStartState for PendingParsingBlockingClassicScriptContext {
- type SourceLoadState = PendingParserBlockingSourceLoad;
-
- fn install_parser_classic_source_load_state(&mut self, state: Self::SourceLoadState) {
- self.source_load = Some(state);
- }
-}
-
-impl ParserClassicScriptSourceLoadWaitState for PendingParsingBlockingClassicScriptContext {
- type SourceLoadWait = SharedScriptSourceLoad;
-
- fn parser_classic_source_load_wait(&self) -> Option<Self::SourceLoadWait> {
- self.source_load
- .as_ref()
- .map(|source_load| source_load.shared_load())
- }
-}
-
pub(super) fn main_parser_blocking_classic_script_item(
owner: FrameDocumentTaskOwner,
input: ParserPreparedClassicScript,
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 a09c6582c..6c1173217 100644
--- a/moli-renderer-v8/src/runtime/phase_one/parser_turn.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/parser_turn.rs
@@ -469,8 +469,6 @@ pub(super) struct ParserDriver<'loader, 'state> {
pub(super) final_url: &'state Url,
pub(super) parser_session: &'state mut DocumentParserSession,
pub(super) scheduler: &'state mut DocumentScriptScheduler,
- pub(super) pending_parsing_blocking_script:
- &'state mut PendingParsingBlockingClassicScriptRunner,
pub(super) buffered_document_preloads: &'state mut BufferedDocumentPreloadState,
pub(super) service_worker_preload_context: Option<&'state ServiceWorkerScriptPreloadContext>,
pub(super) input_closed: &'state bool,
@@ -593,9 +591,11 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {
!pending_parsing_blocking_wait.is_pending(),
"parser owner should not enqueue a new parsing turn while a blocking-wait document turn is still pending"
);
- if !self
- .pending_parsing_blocking_script
- .has_parser_blocking_script()
+ if page_vm
+ .vm()
+ .document_runtime
+ .pending_main_parser_script()
+ .is_none()
{
if self.parser_session.input_is_empty() {
if *self.input_closed {
@@ -608,15 +608,19 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {
return Ok(OwnerStepProgress::Continue);
}
}
- if self
- .pending_parsing_blocking_script
- .has_parser_blocking_script()
+ if let Some(pending) = page_vm
+ .vm_mut()
+ .document_runtime
+ .take_pending_main_parser_script()
{
- let parser_blocking_script_handle = self
- .pending_parsing_blocking_script
- .current_parser_blocking_script_handle();
- let preload_candidate = self
- .pending_parsing_blocking_script
+ // Release the Document's pending slot before any script or callback
+ // can reenter. The local runner owns only this execution, and may
+ // never clear a newer blocker installed by document.write().
+ let mut pending_runner =
+ PendingParsingBlockingClassicScriptRunner::from_parser_blocking_script(pending);
+ let parser_blocking_script_handle =
+ pending_runner.current_parser_blocking_script_handle();
+ let preload_candidate = pending_runner
.current_parser_blocking_script()
.filter(|pending| pending.context().source_load.is_none())
.and_then(|pending| pending.runner_script().cloned());
@@ -645,31 +649,37 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {
&& applied_preload.is_some()
{
debug_assert!(
- self.pending_parsing_blocking_script
- .apply_current_parser_blocking_preloaded_script(
- script_handle,
- prepared_script,
- ),
+ pending_runner.apply_current_parser_blocking_preloaded_script(
+ script_handle,
+ prepared_script,
+ ),
"a parser-blocking preload must complete the same external pending script"
);
}
- if !apply_pending_parser_blocking_source_load_if_ready(
- page_vm,
- self.pending_parsing_blocking_script,
- ) {
+ if !apply_pending_parser_blocking_source_load_if_ready(page_vm, &mut pending_runner) {
+ page_vm
+ .vm_mut()
+ .document_runtime
+ .install_pending_main_parser_script(
+ pending_runner
+ .take_current_parser_blocking_script()
+ .expect("waiting script remains pending"),
+ );
return Ok(OwnerStepProgress::BlockedOnParserScriptSourceLoad);
}
let progress = match resolve_main_parser_blocking_classic_after_runtime_gate(
self.parser_session,
page_vm,
- self.pending_parsing_blocking_script,
+ &mut pending_runner,
"executing stylesheet-unblocked parser-blocking classic script",
)
.await?
{
MainParserBlockingExecutionOutcome::BlockedOnStylesheet(pending) => {
- self.pending_parsing_blocking_script
- .install_parser_blocking_script_blocked_on_execution(*pending);
+ page_vm
+ .vm_mut()
+ .document_runtime
+ .install_pending_main_parser_script(pending.into_script());
None
}
MainParserBlockingExecutionOutcome::StoppedCurrentDocument => {
@@ -680,10 +690,6 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {
}
MainParserBlockingExecutionOutcome::BlockedOnDocumentWriteExternalLoad => {
self.finish_parser_blocking_pause();
- if let Some(script_handle) = parser_blocking_script_handle {
- self.pending_parsing_blocking_script
- .discard_current_parser_blocking_script_if_handle(script_handle);
- }
*pending_parsing_blocking_wait = if page_vm.has_page_resource_completion_route()
{
PendingParsingBlockingWait::PageNetworkingDocumentWriteExternalScript
@@ -700,10 +706,6 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {
};
if let Some(progress) = progress {
self.finish_parser_blocking_pause();
- if let Some(script_handle) = parser_blocking_script_handle {
- self.pending_parsing_blocking_script
- .discard_current_parser_blocking_script_if_handle(script_handle);
- }
return Ok(progress);
}
return Ok(suspend_parser_for_stylesheet_page_task(
@@ -782,16 +784,20 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {
owner_step_progress_after_current_document_stop(page_vm)
}
ParserStepAdvanceOutcome::BlockedOnStylesheet(script) => {
- self.pending_parsing_blocking_script
- .install_parser_blocking_script_blocked_on_execution(*script);
+ page_vm
+ .vm_mut()
+ .document_runtime
+ .install_pending_main_parser_script(script.into_script());
suspend_parser_for_stylesheet_page_task(owner, pending_parsing_blocking_wait)
}
ParserStepAdvanceOutcome::BlockedOnStylesheetParserPause => {
suspend_parser_for_stylesheet_page_task(owner, pending_parsing_blocking_wait)
}
ParserStepAdvanceOutcome::BlockedOnExternalSource(script) => {
- self.pending_parsing_blocking_script
- .install_parser_blocking_script_blocked_on_source_load(*script);
+ page_vm
+ .vm_mut()
+ .document_runtime
+ .install_pending_main_parser_script(script.into_script());
*pending_parsing_blocking_wait = PendingParsingBlockingWait::None;
*owner = ParseTimeOwner::Parser;
OwnerStepProgress::NeedMoreInput
diff --git a/moli-renderer-v8/src/runtime/phase_one/state.rs b/moli-renderer-v8/src/runtime/phase_one/state.rs
index fa8ecbc35..3e9302c0d 100644
--- a/moli-renderer-v8/src/runtime/phase_one/state.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/state.rs
@@ -1,4 +1,3 @@
-use super::parser_blocking_owner::MainParserBlockingSourceLoadWaitOwner;
use super::*;
use crate::document_script_scheduler::ParseTimeDocumentScriptEvent;
@@ -7,7 +6,6 @@ pub(super) struct ParseTimeDriverState {
pub(super) document_character_set: String,
pub(super) parser_session: DocumentParserSession,
pub(super) scheduler: DocumentScriptScheduler,
- pub(super) pending_parsing_blocking_script: PendingParsingBlockingClassicScriptRunner,
pub(super) buffered_document_preloads: Box<BufferedDocumentPreloadState>,
pub(super) service_worker_preload_context: Option<ServiceWorkerScriptPreloadContext>,
pub(super) input_closed: bool,
@@ -28,7 +26,6 @@ impl ParseTimeDriverState {
final_url,
document_character_set: "UTF-8".to_owned(),
scheduler: DocumentScriptScheduler::new(),
- pending_parsing_blocking_script: PendingParsingBlockingClassicScriptRunner::empty(),
buffered_document_preloads: Box::default(),
service_worker_preload_context: None,
input_closed: false,
@@ -41,7 +38,6 @@ impl ParseTimeDriverState {
final_url,
document_character_set: "UTF-8".to_owned(),
scheduler: DocumentScriptScheduler::new(),
- pending_parsing_blocking_script: PendingParsingBlockingClassicScriptRunner::empty(),
buffered_document_preloads: Box::default(),
service_worker_preload_context: None,
input_closed: false,
@@ -154,10 +150,12 @@ impl ConcurrentParseTimeRuntime {
Vec<ParseTimeDocumentScriptEvent>,
Vec<PostParsePageOwnedWork>,
) {
- self.page_vm
- .vm_mut()
- .document_runtime
- .deactivate_main_parser_continuation();
+ let document = &mut self.page_vm.vm_mut().document_runtime;
+ document.deactivate_main_parser_continuation();
+ // The Document outlives this driver on main-resource failure and
+ // navigation. Retire its pending script with the execution owner.
+ // A replacement document.write parser owns its own insertion work.
+ let _ = document.take_pending_main_parser_script();
(
self.page_vm
.page_task_queue
@@ -265,10 +263,12 @@ impl ConcurrentParseTimeRuntime {
pub(super) fn pending_parser_blocking_source_load(
&self,
) -> Option<crate::planning::SharedScriptSourceLoad> {
- let mut owner = MainParserBlockingSourceLoadWaitOwner;
- self.state
- .pending_parsing_blocking_script
- .current_parser_blocking_source_load_wait_action_with_owner(&mut owner)
+ self.page_vm
+ .vm()
+ .document_runtime
+ .pending_main_parser_script()
+ .and_then(|script| script.context().source_load.as_ref())
+ .map(|source| source.shared_load())
}
pub(super) fn has_unready_pending_parser_blocking_source_load(&self) -> bool {
diff --git a/moli-renderer-v8/src/runtime/phase_one/streaming.rs b/moli-renderer-v8/src/runtime/phase_one/streaming.rs
index 08304b7be..f3bfeed07 100644
--- a/moli-renderer-v8/src/runtime/phase_one/streaming.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/streaming.rs
@@ -1088,7 +1088,7 @@ mod tests {
runtime_hooks.owner_wake(),
runtime_hooks.resource_task_runner(),
);
- let page_vm = PageVm::new(
+ let mut page_vm = PageVm::new(
PageId::new_for_testing(1),
local_executor,
&loader,
@@ -1104,21 +1104,21 @@ mod tests {
.vm()
.current_main_document_task_owner()
.expect("main parser test owner");
- state.pending_parsing_blocking_script =
- PendingParsingBlockingClassicScriptRunner::from_parser_blocking_script(
- main_parser_blocking_classic_script_item(
- parser_document_owner,
- crate::parser_script::payload::ParserPreparedClassicScript::new(
- crate::parser_script::payload::ParserClassicScriptMetadata::new(
- script.node_id,
- 1,
- ),
- script,
+ page_vm
+ .vm_mut()
+ .document_runtime
+ .install_pending_main_parser_script(main_parser_blocking_classic_script_item(
+ parser_document_owner,
+ crate::parser_script::payload::ParserPreparedClassicScript::new(
+ crate::parser_script::payload::ParserClassicScriptMetadata::new(
+ script.node_id,
+ 1,
),
- HashSet::new(),
- Some(PendingParserBlockingSourceLoad::ReusablePreload(load)),
+ script,
),
- );
+ HashSet::new(),
+ Some(PendingParserBlockingSourceLoad::ReusablePreload(load)),
+ ));
TestConcurrentParseTimeRuntime {
runtime: ConcurrentParseTimeRuntime::new_parser_owner(
loader,
@@ -1131,6 +1131,28 @@ mod tests {
}
}
+ #[tokio::test]
+ async fn main_resource_failure_retires_the_document_owned_parser_script() {
+ let load = crate::planning::SharedScriptSourceLoad::spawn_for_test(std::future::pending());
+ let fixture = streaming_runtime_with_pending_parser_blocking_source_load(load);
+ assert!(fixture.has_pending_parser_blocking_source_load());
+ let page_vm = fixture.runtime.into_main_resource_load_failed_page_vm();
+ assert!(
+ page_vm
+ .vm()
+ .document_runtime
+ .pending_main_parser_script()
+ .is_none()
+ );
+ assert!(
+ page_vm
+ .vm()
+ .document_runtime
+ .main_parser_continuation_producer()
+ .is_none()
+ );
+ }
+
#[tokio::test]
async fn parser_deferred_source_terminal_remains_retained_until_queue_observation() {
let blocking_load =
diff --git a/moli-renderer-v8/src/types.rs b/moli-renderer-v8/src/types.rs
index 9d6c98eb1..c8210e668 100644
--- a/moli-renderer-v8/src/types.rs
+++ b/moli-renderer-v8/src/types.rs
@@ -1083,6 +1083,7 @@ impl DocumentWriteExternalScriptFetchTarget {
self.task_owner
}
+ #[cfg(test)]
pub(crate) fn load_id(self) -> u64 {
self.load_id
}