Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
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.rsindex 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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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>whereContext: ParserClassicScriptExecutionGateState,diff --git a/moli-renderer-v8/src/parser_script/queue.rs b/moli-renderer-v8/src/parser_script/queue.rsindex 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.rsindex 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 @@ whereSome(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.rsindex 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.rsindex 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-micfinal_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-micfinal_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-micfinal_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-micfinal_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-micfinal_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-micfinal_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-micfinal_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-micfinal_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.getElementByIscheduler: &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.getElemescheduler: &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('bscheduler: &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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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::NeedMoreInputdiff --git a/moli-renderer-v8/src/runtime/phase_one/state.rs b/moli-renderer-v8/src/runtime/phase_one/state.rsindex 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.rsindex 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.rsindex 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}