Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(renderer): defer parser finish across insertion recovery

ldm0f344d6e0be8b
diff --git a/moli-renderer-v8/src/runtime/phase_one/mod.rs b/moli-renderer-v8/src/runtime/phase_one/mod.rs
index 0694fb3ca..523e5b4b8 100644
--- a/moli-renderer-v8/src/runtime/phase_one/mod.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/mod.rs
@@ -3870,6 +3870,115 @@ document.body.setAttribute('data-error-state', [
);
}
+ #[test]
+ fn main_parser_finish_waits_for_transient_insertion_controller() {
+ run_phase_one_large_stack_test(
+ "phase-one-main-parser-finish-after-insertion-controller",
+ main_parser_finish_waits_for_transient_insertion_controller_inner,
+ );
+ }
+
+ fn main_parser_finish_waits_for_transient_insertion_controller_inner() {
+ let runtime = tokio::runtime::Builder::new_current_thread()
+ .enable_all()
+ .build()
+ .expect("current-thread runtime should build");
+
+ runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
+ let _js_runtime = crate::JsRuntime::initialize();
+ let final_url = Url::parse("https://example.test/").expect("test url");
+ let loader_owner =
+ ResourceRequestClient::new(&FetchConfig::default()).expect("default loader");
+ let loader = loader_owner.clone();
+ let mut state = ParseTimeDriverState::new(final_url);
+ state.input_closed = true;
+ let insertion_controller =
+ crate::document_runtime::ParserInsertionController::for_session(
+ &state.parser_session,
+ )
+ .expect("HTML parser should expose an insertion controller");
+ let parser_dom_host = state
+ .parser_session
+ .stream_handle()
+ .borrow_mut()
+ .take_parser_stream_dom_host();
+ let local_executor = JsLocalExecutor::new();
+ let page_vm = PageVm::new(
+ PageId::new_for_testing(103),
+ local_executor,
+ &loader,
+ &default_test_page_vm_env_config(),
+ PageVmRuntimeHooks::standalone_without_owner_reservation_for_test(),
+ parser_dom_host,
+ Instant::now(),
+ )
+ .expect("page vm");
+ let phase_runtime = ConcurrentParseTimeRuntime::new_parser_owner(
+ loader,
+ PageVmInitStage::Load,
+ state,
+ page_vm,
+ );
+
+ let completion = ParseTimePhaseOnePump::new(phase_runtime)
+ .run_to_completion()
+ .await
+ .expect("borrowed parser stream should park instead of finishing");
+ let super::loop_protocol::ParseTimeOwnerCompletion::PendingPageTask(
+ mut phase_runtime,
+ ) = completion
+ else {
+ panic!("borrowed parser stream should publish one continuation task");
+ };
+ assert!(
+ phase_runtime
+ .page_vm
+ .page_task_executor_sources_for_test()
+ .has_scheduler_task_for_executor_test(|descriptor| matches!(
+ descriptor,
+ crate::page_task_queue::RendererPageReadyDescriptor::Networking {
+ owner:
+ crate::page_task_queue::RendererPageNetworkingOwner::MainParserContinuation(
+ _
+ ),
+ ..
+ }
+ )),
+ "deferred finish must cross a selected Page task boundary"
+ );
+
+ drop(insertion_controller);
+ let request_client = phase_runtime
+ .page_vm
+ .main_document_resource_loader()
+ .request_client()
+ .clone();
+ assert!(
+ phase_runtime
+ .page_vm
+ .run_exact_selected_page_task_for_test(
+ crate::runtime::page_vm::PageSelectedTaskTestSelector::MainParserContinuation,
+ &request_client,
+ )
+ .await
+ .expect("main parser continuation should execute"),
+ "the exact deferred-finish continuation should remain selectable"
+ );
+
+ let completion = ParseTimePhaseOnePump::new(phase_runtime)
+ .run_to_completion()
+ .await
+ .expect("unborrowed parser stream should finish");
+ assert!(matches!(
+ completion,
+ super::loop_protocol::ParseTimeOwnerCompletion::AdvancePhase {
+ reason: super::loop_protocol::ParseTimePhaseTransitionReason::ParserCompleted,
+ ..
+ }
+ ));
+ }));
+ }
+
fn full_body_phase_one_parks_on_pending_parser_blocking_source_load_inner() {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
diff --git a/moli-renderer-v8/src/runtime/phase_one/parser_turn.rs b/moli-renderer-v8/src/runtime/phase_one/parser_turn.rs
index 1b73e63cd..21b7e53d8 100644
--- a/moli-renderer-v8/src/runtime/phase_one/parser_turn.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/parser_turn.rs
@@ -553,8 +553,10 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {
{
if self.parser_session.input_is_empty() {
if *self.input_closed {
- self.finish_main_parser(page_vm, parser_document_owner);
- return Ok(OwnerStepProgress::AdvancePhase);
+ return Ok(self.finish_main_parser_or_defer_borrowed_stream(
+ page_vm,
+ parser_document_owner,
+ ));
}
return Ok(OwnerStepProgress::NeedMoreInput);
}
@@ -678,8 +680,7 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {
*parser_step_ready = false;
let progress = if self.parser_session.input_is_empty() {
if *self.input_closed {
- self.finish_main_parser(page_vm, parser_document_owner);
- OwnerStepProgress::AdvancePhase
+ self.finish_main_parser_or_defer_borrowed_stream(page_vm, parser_document_owner)
} else {
OwnerStepProgress::NeedMoreInput
}
@@ -1304,6 +1305,31 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {
outcome
}
+ fn finish_main_parser_or_defer_borrowed_stream(
+ &mut self,
+ page_vm: &mut PageVm,
+ parser_document_owner: crate::frame_owner_model::FrameDocumentTaskOwner,
+ ) -> OwnerStepProgress {
+ if !self.parser_session.has_exclusive_stream_handle() {
+ // A document.write recovery turn can drive this same main stream
+ // to EOF while its temporary ParserInsertionController is still
+ // live on the Page-task stack. EOF is final, but destroying the
+ // stream is only valid after that stack has unwound. Cross the
+ // stable scheduler boundary once; the selected continuation then
+ // re-enters this sole parser runtime with exclusive ownership.
+ assert!(
+ page_vm
+ .vm()
+ .document_runtime
+ .request_main_parser_continuation_if_active(),
+ "main parser EOF with a borrowed stream requires an active continuation route"
+ );
+ return OwnerStepProgress::BlockedOnPageTask;
+ }
+ self.finish_main_parser(page_vm, parser_document_owner);
+ OwnerStepProgress::AdvancePhase
+ }
+
fn finish_main_parser(
&mut self,
page_vm: &mut PageVm,