From 2926d235ce4de2dbb19e8ca32ecf7ea3f618c126 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Mon, 28 Sep 2026 21:43:32 +0800 Subject: [PATCH] fix(navigation): reconcile paused lifecycle after main rebase Run tree beforeunload from the existing Inspector scope so navigation can start its request while the old script remains paused. Bind the active Page per owner-task poll and preserve the beforeunload output prefix and navigation fence without completing a suspended Runtime command. Keep document-replacement termination pauses internal while preserving real output and balancing pauses already reported to frontend sessions. Keep intentional pagehide/unload callbacks debuggable during replacement. Cover root/child lifecycle ordering, 204 recovery, resumable unload, multiple sessions and cancellation between pause notification and loop entry. --- .../tests/navigation_unload.rs | 17 +- .../tests/websocket/navigation_debugger.rs | 1 + .../navigation_debugger/beforeunload.rs | 212 ++++++++++++++++++ moli-renderer-v8/src/devtools/command.rs | 1 + .../src/devtools/command/nested.rs | 6 +- moli-renderer-v8/src/devtools/ingress/main.rs | 56 +++-- .../src/devtools/pause/causality.rs | 3 + moli-renderer-v8/src/devtools/pause/mod.rs | 76 ++++++- moli-renderer-v8/src/devtools/pause/tests.rs | 66 ++++++ moli-renderer-v8/src/runtime/mod.rs | 5 +- moli-renderer-v8/src/runtime/nested_main.rs | 84 +++++-- .../src/runtime/owner_local_store/bound.rs | 5 +- .../src/runtime/owner_local_store/mod.rs | 1 - .../src/script_vm/child_frame_runtime.rs | 20 ++ .../src/script_vm/inspector/outbound.rs | 22 +- .../src/script_vm/inspector/v8_backend.rs | 22 +- 16 files changed, 547 insertions(+), 50 deletions(-) create mode 100644 moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger/beforeunload.rs diff --git a/moli-protocol-server/src/protocol_server/tests/navigation_unload.rs b/moli-protocol-server/src/protocol_server/tests/navigation_unload.rs index 85085ebd691..899ed67b1af 100644 --- a/moli-protocol-server/src/protocol_server/tests/navigation_unload.rs +++ b/moli-protocol-server/src/protocol_server/tests/navigation_unload.rs @@ -112,7 +112,7 @@ async fn assert_navigation_unload_output_order(pause_in_unload: bool) { "Runtime.evaluate", Some(&session.session_id), json!({ - "expression": "addEventListener('unload', () => { debugger; })" + "expression": "addEventListener('unload', () => { debugger; console.log('unload-after-debugger'); })" }), ) .await; @@ -165,6 +165,11 @@ async fn assert_navigation_unload_output_order(pause_in_unload: bool) { ) .await, ); + assert!( + messages + .iter() + .any(|message| { message["id"] == 13 && message.get("error").is_none() }) + ); } if !messages.iter().any(|message| { message["sessionId"] == session.session_id && message["method"] == "Page.loadEventFired" @@ -181,6 +186,16 @@ async fn assert_navigation_unload_output_order(pause_in_unload: bool) { .iter() .position(|message| message["method"] == "Page.frameNavigated") .expect("replacement must commit"); + if pause_in_unload { + let resumed_handler = messages + .iter() + .position(|message| { + message["method"] == "Runtime.consoleAPICalled" + && message["params"]["args"][0]["value"] == "unload-after-debugger" + }) + .expect("unload handler must continue after Debugger.resume"); + assert!(resumed_handler < commit, "{messages:?}"); + } for (method, expected) in [ ( "Runtime.consoleAPICalled", diff --git a/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger.rs b/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger.rs index c4da60352ef..edcdfc599f0 100644 --- a/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger.rs +++ b/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger.rs @@ -1,5 +1,6 @@ use super::*; +mod beforeunload; mod superseded_interception; type TestSocket = diff --git a/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger/beforeunload.rs b/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger/beforeunload.rs new file mode 100644 index 00000000000..9bb9c0c0f38 --- /dev/null +++ b/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger/beforeunload.rs @@ -0,0 +1,212 @@ +use super::*; + +#[tokio::test] +async fn paused_timer_runs_tree_beforeunload_before_fetch_without_resuming() { + check_beforeunload_while_paused(false).await; +} + +#[tokio::test] +async fn paused_runtime_command_survives_beforeunload_and_no_content_navigation() { + check_beforeunload_while_paused(true).await; +} + +async fn check_beforeunload_while_paused(runtime_command: bool) { + let requested = Arc::new(tokio::sync::Notify::new()); + let release = Arc::new(tokio::sync::Notify::new()); + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let address = listener.local_addr().unwrap(); + let app = axum::Router::new().route( + "/", + axum::routing::get({ + let requested = requested.clone(); + let release = release.clone(); + move || { + let requested = requested.clone(); + let release = release.clone(); + async move { + requested.notify_one(); + release.notified().await; + let (status, body) = if runtime_command { + (axum::http::StatusCode::NO_CONTENT, "") + } else { + (axum::http::StatusCode::OK, "replacement") + }; + ( + status, + [(axum::http::header::CONTENT_TYPE, "text/html")], + body, + ) + } + } + }), + ); + let fixture = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() }); + let (cdp_addr, server) = spawn_test_protocol_server().await; + let (mut socket, _) = connect_async(format!( + "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}" + )) + .await + .unwrap(); + let session_id = cdp_create_default_session_and_navigate( + &mut socket, + "data:text/html,old", + ) + .await; + for (id, method, params) in [ + (6, "Debugger.enable", json!({})), + (20, "Network.enable", json!({})), + ( + 21, + "Runtime.addBinding", + json!({"name": "reportBeforeUnload"}), + ), + ] { + send_cdp_command(&mut socket, id, method, Some(&session_id), params).await; + } + assert_eq!( + cdp_runtime_evaluate_string( + &mut socket, + &session_id, + 22, + r#"(() => { + globalThis.trace = []; + globalThis.afterPause = false; + for (const [target, name] of [[window, 'root'], [frames[0], 'child']]) { + target.addEventListener('beforeunload', () => { + trace.push(name); + console.log('beforeunload:' + name); + reportBeforeUnload(name + ':' + afterPause); + }); + } + return 'ready'; + })()"#, + ) + .await, + "ready" + ); + if runtime_command { + send_cdp_command_without_wait( + &mut socket, + 7, + "Runtime.evaluate", + Some(&session_id), + json!({"expression": "debugger; afterPause = true; console.log('outer-after'); trace.join(',')"}), + ) + .await; + recv_until_match(&mut socket, |message| { + message["method"] == "Debugger.paused" + }) + .await; + } else { + pause_in_timer(&mut socket, &session_id, 7, "debugger; afterPause = true;").await; + }; + send_cdp_command_without_wait( + &mut socket, + 8, + "Page.navigate", + Some(&session_id), + json!({"url": format!("http://{address}/")}), + ) + .await; + + let mut phase = "network event"; + let mut messages = Vec::new(); + let checked = timeout(NAVIGATION_TIMEOUT, async { + messages.extend( + recv_until_match(&mut socket, |message| { + message["method"] == "Network.requestWillBeSent" + && message["params"]["request"]["url"] == format!("http://{address}/") + }) + .await, + ); + phase = "HTTP request"; + requested.notified().await; + }) + .await; + // Always release a regressed renderer before reporting the failure. + if checked.is_err() { + release.notify_one(); + send_cdp_command( + &mut socket, + 90, + "Debugger.resume", + Some(&session_id), + json!({"terminateOnResume": true}), + ) + .await; + let _ = socket.close(None).await; + abort_test_cdp_server(server).await; + fixture.abort(); + panic!("paused beforeunload stalled at {phase}: {messages:#?}"); + } + let bindings = messages + .iter() + .filter(|message| message["method"] == "Runtime.bindingCalled") + .map(|message| message["params"]["payload"].clone()) + .collect::>(); + let consoles = messages + .iter() + .filter(|message| message["method"] == "Runtime.consoleAPICalled") + .map(|message| message["params"]["args"][0]["value"].clone()) + .collect::>(); + // Neither beforeunload nor its output may resume the original script. + let resumed_early = messages + .iter() + .any(|message| message["method"] == "Debugger.resumed"); + release.notify_one(); + let mut completed = recv_until_id(&mut socket, 8).await; + if runtime_command { + completed.extend( + send_cdp_command( + &mut socket, + 24, + "Debugger.resume", + Some(&session_id), + json!({}), + ) + .await, + ); + if !completed.iter().any(|message| message["id"] == 7) { + completed.extend(recv_until_id(&mut socket, 7).await); + } + } else if !completed + .iter() + .any(|message| message["method"] == "Page.loadEventFired") + { + completed.extend( + recv_until_match(&mut socket, |message| { + message["method"] == "Page.loadEventFired" + }) + .await, + ); + } + let _ = socket.close(None).await; + abort_test_cdp_server(server).await; + fixture.abort(); + assert_eq!(bindings, vec![json!("root:false"), json!("child:false")]); + assert_eq!( + consoles, + vec![json!("beforeunload:root"), json!("beforeunload:child")] + ); + assert!(!resumed_early); + if runtime_command { + assert!(completed.iter().any(|message| { + message["id"] == 7 && message["result"]["result"]["value"] == "root,child" + })); + assert!( + completed + .iter() + .any(|message| message["id"] == 24 && message.get("error").is_none()) + ); + assert_eq!( + completed + .iter() + .filter(|message| { + message["method"] == "Runtime.consoleAPICalled" + && message["params"]["args"][0]["value"] == "outer-after" + }) + .count(), + 1 + ); + } +} diff --git a/moli-renderer-v8/src/devtools/command.rs b/moli-renderer-v8/src/devtools/command.rs index 6cb06c1602e..ee454ccab3e 100644 --- a/moli-renderer-v8/src/devtools/command.rs +++ b/moli-renderer-v8/src/devtools/command.rs @@ -304,6 +304,7 @@ pub(crate) enum RendererDevToolsMainNestedDispatch { /// V8 session dispatch followed by a native terminal in the same Main turn. NativeInspectorSession, PageAgent, + BeforeUnload, OwnerOnly, } diff --git a/moli-renderer-v8/src/devtools/command/nested.rs b/moli-renderer-v8/src/devtools/command/nested.rs index 5ab57f1b644..ea061bdfaae 100644 --- a/moli-renderer-v8/src/devtools/command/nested.rs +++ b/moli-renderer-v8/src/devtools/command/nested.rs @@ -6,7 +6,7 @@ use crate::runtime::RendererPageCommand; impl RendererPageCommand { pub(crate) fn nested_dispatch(&self) -> RendererDevToolsMainNestedDispatch { - use RendererDevToolsMainNestedDispatch::{InspectorSession, OwnerOnly, PageAgent}; + use RendererDevToolsMainNestedDispatch::{BeforeUnload, InspectorSession, OwnerOnly, PageAgent}; match self { Self::WebMcp { .. } => OwnerOnly, Self::ForDocument { command, .. } => command.nested_dispatch(), @@ -18,6 +18,9 @@ impl RendererPageCommand { } Self::Inspector(envelope) if envelope.is_runtime_binding_removal_commit() => PageAgent, Self::Inspector(_) => OwnerOnly, + // beforeunload reuses the Inspector callback's entered V8 scope + // while the old document is paused; ordinary Page dispatch cannot. + Self::CheckMainDocumentBeforeUnload => BeforeUnload, // These handlers read native document/agent state without entering // a new V8 scope. They can use the existing pause callback boundary. Self::HasPendingLocationNavigation @@ -143,7 +146,6 @@ impl RendererPageCommand { | Self::PerformanceMetricSnapshot | Self::RuntimeCollectGarbage | Self::StopDocumentLifecycle - | Self::CheckMainDocumentBeforeUnload | Self::UnloadMainDocumentForNavigationCommit | Self::SetInlineStyleSheetTextForStyleSheetId { .. } | Self::ScrollNodeIntoViewIfNeeded { .. } diff --git a/moli-renderer-v8/src/devtools/ingress/main.rs b/moli-renderer-v8/src/devtools/ingress/main.rs index 59eb9f73040..b1d530a953f 100644 --- a/moli-renderer-v8/src/devtools/ingress/main.rs +++ b/moli-renderer-v8/src/devtools/ingress/main.rs @@ -128,6 +128,18 @@ impl RendererInspectorMainCommand { (command, reply_tx) } + pub(crate) fn into_nested_beforeunload_reply( + self, + ) -> tokio::sync::oneshot::Sender> { + assert_eq!( + self.nested_dispatch(), + RendererDevToolsMainNestedDispatch::BeforeUnload, + "only beforeunload may enter the nested lifecycle callback" + ); + self.owner_reply_tx + .expect("a nested beforeunload command must retain its completion sender") + } + #[cfg(test)] fn claimed_by(&self) -> Option { self.claimed_by @@ -536,25 +548,36 @@ impl RendererInspectorMainIngress { pub(crate) fn claim_for_owner(&self) -> Option { self.shared.owner_wake_armed.store(false, Ordering::Release); - let command = self.claim_next(RendererInspectorMainCommandConsumer::Owner); + let command = self.claim_next(RendererInspectorMainCommandConsumer::Owner, true); if command.is_none() && self.shared.state.lock().lanes.has_ready() { self.notify_execution_opportunities(); } command } - pub(crate) fn claim_for_pause(&self) -> Option { - self.claim_next(RendererInspectorMainCommandConsumer::Pause) + pub(crate) fn claim_for_pause( + &self, + beforeunload_allowed: bool, + ) -> Option { + self.claim_next( + RendererInspectorMainCommandConsumer::Pause, + beforeunload_allowed, + ) } fn claim_next( &self, consumer: RendererInspectorMainCommandConsumer, + beforeunload_allowed: bool, ) -> Option { let mut state = self.shared.state.lock(); let (_, mut command) = state.lanes.claim_next(|command| { consumer != RendererInspectorMainCommandConsumer::Pause - || command.nested_dispatch() != RendererDevToolsMainNestedDispatch::OwnerOnly + || match command.nested_dispatch() { + RendererDevToolsMainNestedDispatch::OwnerOnly => false, + RendererDevToolsMainNestedDispatch::BeforeUnload => beforeunload_allowed, + _ => true, + } })?; command.claimed_by = Some(consumer); let claim = match consumer { @@ -564,7 +587,8 @@ impl RendererInspectorMainIngress { RendererInspectorMainCommandConsumer::Pause => match command.nested_dispatch() { RendererDevToolsMainNestedDispatch::InspectorSession => None, RendererDevToolsMainNestedDispatch::PageAgent - | RendererDevToolsMainNestedDispatch::NativeInspectorSession => { + | RendererDevToolsMainNestedDispatch::NativeInspectorSession + | RendererDevToolsMainNestedDispatch::BeforeUnload => { Some(RendererInspectorMainCommandClaim::Page) } RendererDevToolsMainNestedDispatch::OwnerOnly => { @@ -849,7 +873,7 @@ mod tests { r#"{"id":1,"method":"Runtime.getProperties","params":{"objectId":"first"}}"#, ); - let pause = ingress.claim_for_pause(); + let pause = ingress.claim_for_pause(true); let owner = ingress.claim_for_owner(); assert_eq!( usize::from(pause.is_some()) + usize::from(owner.is_some()), @@ -887,13 +911,13 @@ mod tests { let mut first = ingress.claim_for_owner().expect("first ready Main session"); assert!(first.raw_json().contains(r#""a1""#)); let second = ingress - .claim_for_pause() + .claim_for_pause(true) .expect("the other Main session remains independently ready"); assert!(second.raw_json().contains(r#""b1""#)); assert!(ingress.claim_for_owner().is_none()); ingress.first_dispatch_guard(&mut first).release(); - let third = ingress.claim_for_pause().expect("a2 after a1 dispatch"); + let third = ingress.claim_for_pause(true).expect("a2 after a1 dispatch"); assert!(third.raw_json().contains(r#""a2""#)); } @@ -983,7 +1007,7 @@ mod tests { r#"{"id":2,"method":"Runtime.getProperties","params":{"objectId":"next"}}"#, ); let mut command = ingress - .claim_for_pause() + .claim_for_pause(true) .expect("the direct Inspector command should be claimable"); assert!( ingress.claim_for_owner().is_none(), @@ -1105,7 +1129,7 @@ mod tests { ), ); let mut command = ingress - .claim_for_pause() + .claim_for_pause(true) .expect("the direct Inspector command must reach nested Main"); ingress.first_dispatch_guard(&mut command).release(); publisher @@ -1199,14 +1223,14 @@ mod tests { ); let mut page = ingress - .claim_for_pause() + .claim_for_pause(true) .expect("the Page agent command should be first"); assert_eq!( page.nested_dispatch(), RendererDevToolsMainNestedDispatch::PageAgent ); assert!( - ingress.claim_for_pause().is_none(), + ingress.claim_for_pause(true).is_none(), "the V8 command must remain behind the Page agent first-dispatch boundary" ); @@ -1220,7 +1244,7 @@ mod tests { .expect("test Page-agent output"); ingress.first_dispatch_guard(&mut page).release(); let v8 = ingress - .claim_for_pause() + .claim_for_pause(true) .expect("the V8 command should follow Page dispatch while its reply is retained"); assert_eq!( v8.nested_dispatch(), @@ -1241,7 +1265,7 @@ mod tests { r#"{"id":1,"method":"Runtime.evaluate","params":{"expression":"1 + 1"}}"#, ); let nested = ingress - .claim_for_pause() + .claim_for_pause(true) .expect("default-world Runtime.evaluate should be pumpable by nested Main"); assert_eq!( nested.claimed_by(), @@ -1256,7 +1280,7 @@ mod tests { r#"{"id":2,"method":"Runtime.evaluate","params":{"contextId":41,"expression":"2 + 2"}}"#, ); let explicit_context = ingress - .claim_for_pause() + .claim_for_pause(true) .expect("an Inspector-native context id should remain pumpable by nested Main"); assert_eq!( explicit_context.claimed_by(), @@ -1280,7 +1304,7 @@ mod tests { RendererPageStateCapturePolicy::ProtocolTurn, ); - assert!(ingress.claim_for_pause().is_none()); + assert!(ingress.claim_for_pause(true).is_none()); let owner = ingress .claim_for_owner() .expect("the ordinary owner receiver must claim owner-only Main work"); diff --git a/moli-renderer-v8/src/devtools/pause/causality.rs b/moli-renderer-v8/src/devtools/pause/causality.rs index 701fe1cacd7..009effe0da1 100644 --- a/moli-renderer-v8/src/devtools/pause/causality.rs +++ b/moli-renderer-v8/src/devtools/pause/causality.rs @@ -73,6 +73,9 @@ pub(super) struct RendererInspectorPausePreface { #[derive(Clone, Debug, PartialEq)] pub(crate) enum RendererInspectorPauseNotificationRoute { OrdinaryTurn, + PublishPrefix { + preface: Vec, + }, PublishImmediately { preface: Vec, command_output: Option, diff --git a/moli-renderer-v8/src/devtools/pause/mod.rs b/moli-renderer-v8/src/devtools/pause/mod.rs index 6159643be1a..f15c4ae4e80 100644 --- a/moli-renderer-v8/src/devtools/pause/mod.rs +++ b/moli-renderer-v8/src/devtools/pause/mod.rs @@ -57,6 +57,9 @@ struct RendererInspectorPauseBridgeState { quit_requested: bool, session_detach_arms: usize, document_replacements: usize, + unload_callbacks: usize, + terminate_replacement_pause: bool, + replacement_pauses_awaiting_resumed: HashSet<(RendererDevToolsAgentToken, DevToolsSessionKey)>, target_closed: bool, pending_prefaces: VecDeque, paused_sessions_awaiting_resumed: HashSet<(RendererDevToolsAgentToken, DevToolsSessionKey)>, @@ -76,6 +79,21 @@ pub(crate) struct RendererInspectorPausePrefaceGuard { id: u64, } +#[must_use] +pub(crate) struct RendererInspectorUnloadCallbackGuard { + bridge: RendererInspectorPauseBridge, +} + +impl Drop for RendererInspectorUnloadCallbackGuard { + fn drop(&mut self) { + let mut state = self.bridge.shared.state.lock(); + state.unload_callbacks = state + .unload_callbacks + .checked_sub(1) + .expect("unload callback scope underflow"); + } +} + #[derive(Clone)] pub(crate) struct RendererInspectorPauseLoopWake { shared: Weak, @@ -127,6 +145,9 @@ impl RendererInspectorPauseBridge { quit_requested: false, session_detach_arms: 0, document_replacements: 0, + unload_callbacks: 0, + terminate_replacement_pause: false, + replacement_pauses_awaiting_resumed: HashSet::new(), target_closed: false, pending_prefaces: VecDeque::new(), paused_sessions_awaiting_resumed: HashSet::new(), @@ -372,6 +393,20 @@ impl RendererInspectorPauseBridge { true } + pub(crate) fn begin_unload_callbacks(&self) -> RendererInspectorUnloadCallbackGuard { + let mut state = self.shared.state.lock(); + // Replacement first terminates suspended old work, then deliberately + // runs pagehide/unload before committing. Those callbacks must remain + // debuggable, including when a second preparation overlaps them. + state.unload_callbacks = state + .unload_callbacks + .checked_add(1) + .expect("unload callback scope overflow"); + RendererInspectorUnloadCallbackGuard { + bridge: self.clone(), + } + } + pub(crate) fn finish_document_replacement(&self) { let mut state = self.shared.state.lock(); state.document_replacements = state @@ -389,7 +424,9 @@ impl RendererInspectorPauseBridge { if state.target_closed { return Err(RendererInspectorPauseExitReason::TargetClosed); } - if state.document_replacements != 0 { + if (state.document_replacements != 0 && state.unload_callbacks == 0) + || state.terminate_replacement_pause + { return Err(RendererInspectorPauseExitReason::DocumentReplacement); } if state.session_detach_arms != 0 { @@ -418,6 +455,7 @@ impl RendererInspectorPauseBridge { state.phase = RendererInspectorPausePhase::Running; state.pause_loop_policy = RendererInspectorPauseLoopPolicy::MainAndIo; state.quit_requested = false; + state.terminate_replacement_pause = false; // Commands that lost the nested-loop race stay in their route-specific // ingress. Main retains its owner task; IO retains owner and interrupt // execution chances. @@ -438,13 +476,17 @@ impl RendererInspectorPauseBridge { state.route = None; state.pending_prefaces.clear(); state.paused_sessions_awaiting_resumed.clear(); + state.replacement_pauses_awaiting_resumed.clear(); state.pending_command_transition = None; match state.phase { - RendererInspectorPausePhase::Running => {} + RendererInspectorPausePhase::Running => { + state.terminate_replacement_pause = false; + } RendererInspectorPausePhase::Entering => { state.phase = RendererInspectorPausePhase::Running; state.pause_loop_policy = RendererInspectorPauseLoopPolicy::MainAndIo; state.quit_requested = false; + state.terminate_replacement_pause = false; } RendererInspectorPausePhase::Paused => { state.quit_requested = true; @@ -460,6 +502,7 @@ impl RendererInspectorPauseBridge { state.quit_requested = true; state.pending_prefaces.clear(); state.paused_sessions_awaiting_resumed.clear(); + state.replacement_pauses_awaiting_resumed.clear(); state.pending_command_transition = None; self.shared.pause_loop_wake.notify_all(); } @@ -511,6 +554,16 @@ impl RendererInspectorPauseBridge { if is_paused_notification && (state.route.is_none() || state.session_detach_arms != 0) { return RendererInspectorPauseNotificationRoute::Drop; } + if is_resumed_notification + && state + .replacement_pauses_awaiting_resumed + .remove(&session_route) + { + return RendererInspectorPauseNotificationRoute::Drop; + } + let replacement_pause = is_paused_notification + && ((state.document_replacements != 0 && state.unload_callbacks == 0) + || state.terminate_replacement_pause); let preface = if is_paused_notification { state .pending_prefaces @@ -524,7 +577,7 @@ impl RendererInspectorPauseBridge { } else { Vec::new() }; - if is_paused_notification { + if is_paused_notification && !replacement_pause { state .paused_sessions_awaiting_resumed .insert(session_route.clone()); @@ -572,6 +625,20 @@ impl RendererInspectorPauseBridge { state.pause_loop_policy = RendererInspectorPauseLoopPolicy::IoOnly; } } + if replacement_pause { + // V8 can report another break in an old-document timer while its + // prepared replacement is crossing the commit boundary. The pause + // loop will terminate that execution immediately, without serving + // frontend commands. Preserve real output before the break, but do + // not expose this internal termination cycle as an inspectable pause. + // Retain the decision even if preparation is cancelled before V8 + // enters its loop, otherwise an unreported pause could block forever. + state.terminate_replacement_pause = true; + state + .replacement_pauses_awaiting_resumed + .insert(session_route); + return RendererInspectorPauseNotificationRoute::PublishPrefix { preface }; + } if state.phase == RendererInspectorPausePhase::Running && !resumes_reported_pause { RendererInspectorPauseNotificationRoute::OrdinaryTurn } else { @@ -591,6 +658,9 @@ impl RendererInspectorPauseBridge { state .paused_sessions_awaiting_resumed .remove(&(agent_token, session.clone())); + state + .replacement_pauses_awaiting_resumed + .remove(&(agent_token, session.clone())); state .pending_prefaces .retain(|preface| preface.agent_token != agent_token || &preface.session != session); diff --git a/moli-renderer-v8/src/devtools/pause/tests.rs b/moli-renderer-v8/src/devtools/pause/tests.rs index 78a23618b7f..045e0dee841 100644 --- a/moli-renderer-v8/src/devtools/pause/tests.rs +++ b/moli-renderer-v8/src/devtools/pause/tests.rs @@ -75,6 +75,72 @@ fn route_paused(bridge: &RendererInspectorPauseBridge) -> RendererInspectorPause })) } +#[test] +fn replacement_termination_preserves_output_and_balances_frontend_pause_events() { + let bridge = RendererInspectorPauseBridge::default(); + configure_page(&bridge, PageId::new_for_testing(1)); + let routes = [outbound_route(&bridge), outbound_route(&bridge)]; + let paused = json!({"method": "Debugger.paused", "params": {"callFrames": []}}); + let resumed = json!({"method": "Debugger.resumed", "params": {}}); + for route in &routes { + expect_immediate_preface(route.route_notification(&paused)); + } + assert!(bridge.enter_pause().is_some()); + assert!(bridge.begin_document_replacement()); + assert_eq!( + bridge.wait_for_pause_work(|| Some(())), + Err(RendererInspectorPauseExitReason::DocumentReplacement) + ); + bridge.leave_pause(); + for route in &routes { + // The pause the frontend actually saw still needs its resumed event. + expect_immediate_preface(route.route_notification(&resumed)); + } + { + let _unload = bridge.begin_unload_callbacks(); + for route in &routes { + expect_immediate_preface(route.route_notification(&paused)); + } + assert!(bridge.enter_pause().is_some()); + assert_eq!(bridge.wait_for_pause_work(|| Some(42)), Ok(42)); + bridge.leave_pause(); + for route in &routes { + expect_immediate_preface(route.route_notification(&resumed)); + } + } + let prefix = RendererRuntimeInspectorMessage::protocol(json!({ + "method": "Runtime.consoleAPICalled", "params": {"type": "log"} + })); + for route in &routes { + let _preface = route.stage_pause_preface(vec![prefix.clone()]); + assert_eq!( + route.route_notification(&paused), + RendererInspectorPauseNotificationRoute::PublishPrefix { + preface: vec![prefix.clone()] + } + ); + } + // Cancellation between notification and loop entry cannot strand an + // unreported V8 pause. Its termination decision belongs to this pause. + bridge.finish_document_replacement(); + assert!(bridge.enter_pause().is_some()); + assert_eq!( + bridge.wait_for_pause_work(|| Some(())), + Err(RendererInspectorPauseExitReason::DocumentReplacement) + ); + bridge.leave_pause(); + for route in &routes { + assert_eq!( + route.route_notification(&resumed), + RendererInspectorPauseNotificationRoute::Drop + ); + expect_immediate_preface(route.route_notification(&paused)); + } + assert!(bridge.enter_pause().is_some()); + assert_eq!(bridge.wait_for_pause_work(|| Some(42)), Ok(42)); + bridge.leave_pause(); +} + fn response_sender( call_id: i32, ) -> ( diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rs index c6ea9d4a466..87d5eb38aeb 100644 --- a/moli-renderer-v8/src/runtime/mod.rs +++ b/moli-renderer-v8/src/runtime/mod.rs @@ -514,7 +514,10 @@ pub(crate) use crate::service_worker_runtime::{ ServiceWorkerSyncRegistrationResult, ServiceWorkerVersionId, ServiceWorkerWorkerMessage, service_worker_exposed_client_id, }; -pub(crate) use nested_main::dispatch_nested_main_page_command; +pub(crate) use nested_main::{ + dispatch_nested_main_beforeunload, dispatch_nested_main_page_command, + nested_main_beforeunload_is_allowed, +}; static NEXT_RENDERER_OWNER_LOCAL_HOST_ID: AtomicU64 = AtomicU64::new(1); diff --git a/moli-renderer-v8/src/runtime/nested_main.rs b/moli-renderer-v8/src/runtime/nested_main.rs index c38f481331c..4f8ce6a0446 100644 --- a/moli-renderer-v8/src/runtime/nested_main.rs +++ b/moli-renderer-v8/src/runtime/nested_main.rs @@ -1,4 +1,4 @@ -use std::{cell::RefCell, marker::PhantomData, ptr::NonNull, rc::Rc}; +use std::{cell::RefCell, future::Future, marker::PhantomData, pin::Pin, ptr::NonNull, rc::Rc}; use anyhow::{Result, anyhow}; @@ -25,7 +25,7 @@ thread_local! { /// V8 invokes its pause loop synchronously on the renderer owner thread. The /// outer Page command remains suspended on that same stack, so the pointer is /// valid only for this guard's lifetime and is never sent to another thread. -pub(super) struct ActiveNestedMainPageGuard { +struct ActiveNestedMainPageGuard { previous: Option, _owner_local: PhantomData>, } @@ -38,16 +38,27 @@ impl Drop for ActiveNestedMainPageGuard { } } -pub(super) fn bind_active_nested_main_page(entry: &mut LivePageEntry) -> ActiveNestedMainPageGuard { +pub(super) fn scope_active_nested_main_page<'a, R: 'a>( + entry: &'a mut LivePageEntry, + operation: impl FnOnce(&'a mut LivePageEntry) -> Pin> + 'a>>, +) -> Pin> + 'a>> { let active_page = ActiveNestedMainPage { - page_vm: NonNull::from(entry.page_vm_mut()), entry_slot: entry.slot.clone(), + page_vm: NonNull::from(entry.page_vm_mut()), }; - let previous = ACTIVE_NESTED_MAIN_PAGE.with(|active| active.borrow_mut().replace(active_page)); - ActiveNestedMainPageGuard { - previous, - _owner_local: PhantomData, - } + let mut operation = operation(entry); + Box::pin(std::future::poll_fn(move |cx| { + // Bind every owner action, including timers and lifecycle tasks, only + // during its poll. A Pending future must not leave another Page's + // pointer installed on this shared owner thread. + let previous = + ACTIVE_NESTED_MAIN_PAGE.with(|active| active.borrow_mut().replace(active_page.clone())); + let _guard = ActiveNestedMainPageGuard { + previous, + _owner_local: PhantomData, + }; + operation.as_mut().poll(cx) + })) } pub(crate) fn dispatch_nested_main_page_command( @@ -59,22 +70,61 @@ pub(crate) fn dispatch_nested_main_page_command( super::RendererDevToolsMainNestedDispatch::PageAgent, "nested Page dispatch must not enter V8 through the suspended Page owner" ); - let active = ACTIVE_NESTED_MAIN_PAGE - .try_with(|active| active.borrow().clone()) - .ok() - .flatten() - .ok_or_else(|| anyhow!("nested Main receiver has no active Page owner stack"))?; + let active = active_nested_main_page()?; - // SAFETY: `bind_active_nested_main_page` installs this pointer immediately + // SAFETY: `scope_active_nested_main_page` installs this pointer immediately // around the owner-local Page dispatch that can enter V8. A normal debugger // pause synchronously suspends that outer dispatch, and this callback runs // on the same owner thread before the guard is dropped. Instrumentation // pauses never claim Main work. The nested borrow ends before V8 resumes // the outer Page call. - let page_vm = unsafe { active.page_vm.as_ptr().as_mut() } - .ok_or_else(|| anyhow!("nested Main Page pointer was unexpectedly null"))?; + let page_vm = unsafe { &mut *active.page_vm.as_ptr() }; first_dispatch.release(); let reply: RendererPageReply = page_vm.dispatch_renderer_page_command(command)?; + nested_main_completion(&active, page_vm, reply) +} + +fn active_nested_main_page() -> Result { + ACTIVE_NESTED_MAIN_PAGE + .try_with(|active| active.borrow().clone()) + .ok() + .flatten() + .ok_or_else(|| anyhow!("nested Main receiver has no active Page owner stack")) +} + +pub(crate) fn nested_main_beforeunload_is_allowed() -> bool { + let Ok(active) = active_nested_main_page() else { + return false; + }; + // SAFETY: the owner action is synchronously suspended in V8's pause loop. + let runtime = &unsafe { active.page_vm.as_ref() }.vm().document_runtime; + // A navigation may interrupt an ordinary paused script, but must wait for + // an already-running tree beforeunload/unload check to finish. Reuse the + // Document's actual lifecycle guard, including script-initiated checks. + !runtime.has_document_unload_counter(runtime.document_handle()) +} + +pub(crate) fn dispatch_nested_main_beforeunload( + scope: &mut v8::PinScope<'_, '_, ()>, + mut first_dispatch: RendererInspectorMainFirstDispatchGuard, +) -> Result { + let active = active_nested_main_page()?; + // SAFETY: the same suspended owner-stack binding as Page-agent dispatch. + // The Inspector callback supplies the already-entered isolate scope; this + // path must not reacquire RendererDocumentIsolate or finish the outer turn. + let page_vm = unsafe { &mut *active.page_vm.as_ptr() }; + first_dispatch.release(); + let allowed = page_vm + .vm_mut() + .check_main_document_beforeunload_in_inspector_scope(scope); + nested_main_completion(&active, page_vm, RendererPageReply::Bool(allowed)) +} + +fn nested_main_completion( + active: &ActiveNestedMainPage, + page_vm: &mut PageVm, + reply: RendererPageReply, +) -> Result { // The enclosing turn is suspended inside V8, so its owner-slot snapshot // still describes the state before the pause. Capture the live VM for this // nested handler without committing/replacing the enclosing owner turn. diff --git a/moli-renderer-v8/src/runtime/owner_local_store/bound.rs b/moli-renderer-v8/src/runtime/owner_local_store/bound.rs index a5b7a9703fe..9437a1b00b1 100644 --- a/moli-renderer-v8/src/runtime/owner_local_store/bound.rs +++ b/moli-renderer-v8/src/runtime/owner_local_store/bound.rs @@ -283,7 +283,10 @@ where R: 'static, F: for<'a> FnOnce(&'a mut LivePageEntry) -> EntryLocalTaskFuture<'a, R> + 'static, { - run_typed_entry_on_bound_owner_local_store_local_task(local_executor, entry, operation).await + run_typed_entry_on_bound_owner_local_store_local_task(local_executor, entry, move |entry| { + crate::runtime::nested_main::scope_active_nested_main_page(entry, operation) + }) + .await } pub(in crate::runtime) fn take_entry_for_command_on_bound_owner_local_store( diff --git a/moli-renderer-v8/src/runtime/owner_local_store/mod.rs b/moli-renderer-v8/src/runtime/owner_local_store/mod.rs index a3e134e9236..b2637d6b201 100644 --- a/moli-renderer-v8/src/runtime/owner_local_store/mod.rs +++ b/moli-renderer-v8/src/runtime/owner_local_store/mod.rs @@ -2759,7 +2759,6 @@ impl RendererOwnerLocalStore { .document_replacement_lifecycle_action_snapshot(); let command_epoch = Self::advance_command_epoch(entry); let slot = entry.slot.clone(); - let _nested_main_page = super::nested_main::bind_active_nested_main_page(entry); let mut reply = slot .dispatch_async_owned(command_epoch, entry.page_vm_mut(), command) .await; diff --git a/moli-renderer-v8/src/script_vm/child_frame_runtime.rs b/moli-renderer-v8/src/script_vm/child_frame_runtime.rs index a208e293616..4b22cd2d00e 100644 --- a/moli-renderer-v8/src/script_vm/child_frame_runtime.rs +++ b/moli-renderer-v8/src/script_vm/child_frame_runtime.rs @@ -524,7 +524,27 @@ impl ScriptVm { }) } + pub(crate) fn check_main_document_beforeunload_in_inspector_scope( + &mut self, + scope: &mut v8::PinScope<'_, '_, ()>, + ) -> bool { + let context = v8::Local::new(scope, &self.page_default_context); + let scope = &mut v8::ContextScope::new(scope, context); + // The paused owner already holds the document isolate. Keep the host + // alive without a RefCell borrow across reentrant author callbacks. + let context_host = Rc::clone(&self._context_host); + let host_ptr = (*context_host).as_ptr(); + let allowed = unsafe { &mut *host_ptr }.dispatch_main_document_tree_beforeunload(scope); + // A paused Runtime command may own the active recorder. Flush its + // concrete prefix just as for a modal dialog, without closing that + // recorder or completing the suspended task. The navigation reply + // fences this prefix so console/binding output precedes the fetch. + unsafe { &*host_ptr }.publish_live_turn_output_prefix(); + allowed + } + pub(crate) fn unload_main_document_for_navigation_commit(&mut self) -> anyhow::Result<()> { + let _unload_callbacks = self.devtools_target().pause_ref().begin_unload_callbacks(); self.with_default_context_scope(|scope, host_ptr| { JsContextHost::dispatch_main_document_unload_for_navigation_commit(scope, host_ptr); Ok(()) diff --git a/moli-renderer-v8/src/script_vm/inspector/outbound.rs b/moli-renderer-v8/src/script_vm/inspector/outbound.rs index 8660610a7b6..31e137f40b5 100644 --- a/moli-renderer-v8/src/script_vm/inspector/outbound.rs +++ b/moli-renderer-v8/src/script_vm/inspector/outbound.rs @@ -223,7 +223,10 @@ impl InspectorOutbound { RendererInspectorPauseNotificationRoute::PublishImmediately { preface, command_output, - } => return self.publish_pause_value(preface, command_output, value), + } => return self.publish_pause_value(preface, command_output, Some(value)), + RendererInspectorPauseNotificationRoute::PublishPrefix { preface } => { + return self.publish_pause_value(preface, None, None); + } RendererInspectorPauseNotificationRoute::Drop => return, } } @@ -241,7 +244,7 @@ impl InspectorOutbound { &self, mut preface: Vec, command_output: Option, - value: Value, + value: Option, ) { let session = self .session @@ -264,9 +267,18 @@ impl InspectorOutbound { .output_journal .as_ref() .expect("a debugger pause notification requires a concrete Page output stream"); - preface.push(RendererRuntimeInspectorMessage::from_v8_inspector_message( - value, - )); + if let Some(value) = value { + preface.push(RendererRuntimeInspectorMessage::from_v8_inspector_message( + value, + )); + } + if preface.is_empty() { + if let Some(recorder) = command_turn_output { + output_journal.append_records(recorder.drain_records()); + } + let _ = output_journal.publish_pending(); + return; + } let (causal_command, batch) = match command_output { Some(command_output) => ( Some(command_output.causal_identity), diff --git a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs index 7febcb73b29..c6563a161da 100644 --- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs +++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs @@ -29,7 +29,8 @@ use crate::{ RendererDevToolsIoCommandKind, RendererDevToolsIoCommandPayload, RendererDevToolsMainNestedDispatch, RendererOwnerReply, RendererPageCommand, RendererRuntimeCommandOutput, RendererRuntimeInspectorMessage, - RendererRuntimeInspectorResponseSender, dispatch_nested_main_page_command, + RendererRuntimeInspectorResponseSender, dispatch_nested_main_beforeunload, + dispatch_nested_main_page_command, nested_main_beforeunload_is_allowed, }, }; pub(in crate::script_vm) use interrupt::finish_page_close_termination; @@ -211,7 +212,7 @@ impl RendererInspectorSessionExecutorLocal { { self.target .main_ref() - .claim_for_pause() + .claim_for_pause(nested_main_beforeunload_is_allowed()) .map(RendererInspectorNestedCommand::Main) .or_else(|| { self.target @@ -228,7 +229,7 @@ impl RendererInspectorSessionExecutorLocal { .or_else(|| { self.target .main_ref() - .claim_for_pause() + .claim_for_pause(nested_main_beforeunload_is_allowed()) .map(RendererInspectorNestedCommand::Main) }), }; @@ -303,6 +304,21 @@ impl RendererInspectorSessionExecutorLocal { mut command: RendererInspectorMainCommand, ) { match command.nested_dispatch() { + RendererDevToolsMainNestedDispatch::BeforeUnload => { + let first_dispatch = self.target.main_ref().first_dispatch_guard(&mut command); + let reply_tx = command.into_nested_beforeunload_reply(); + // SAFETY: V8 synchronously called this pause loop on the owner + // thread with this isolate entered. Reuse its callback scope; + // borrowing the ScriptVm's isolate holder again would reenter + // the suspended owner's mutable isolate borrow. + let isolate = unsafe { &mut *self.isolate.get() }; + let isolate = unsafe { v8::Isolate::ref_from_raw_isolate_ptr_mut(isolate) }; + v8::callback_scope!(unsafe let scope, isolate); + let result = dispatch_nested_main_beforeunload(scope, first_dispatch) + .map(|output| RendererOwnerReply::AsyncPageCommandRan(Box::new(output))); + let _ = reply_tx.send(result); + return; + } RendererDevToolsMainNestedDispatch::PageAgent => { let first_dispatch = self.target.main_ref().first_dispatch_guard(&mut command); let (page_command, reply_tx) = command.into_nested_agent_parts();