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();