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 08af97c637a..60d3278f7a8 100644 --- a/moli-protocol-server/src/protocol_server/tests/navigation_unload.rs +++ b/moli-protocol-server/src/protocol_server/tests/navigation_unload.rs @@ -114,7 +114,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; @@ -167,6 +167,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" @@ -183,6 +188,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 1c341e0edb0..89dbf3084b0 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..981fa36b778 --- /dev/null +++ b/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger/beforeunload.rs @@ -0,0 +1,214 @@ +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( + discover_browser_websocket_url(cdp_addr) + .await + .expect("discover browser endpoint"), + ) + .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-protocol/src/conn/dispatch.rs b/moli-protocol/src/conn/dispatch.rs index 6c3ed1054cf..9ab9febf0b1 100644 --- a/moli-protocol/src/conn/dispatch.rs +++ b/moli-protocol/src/conn/dispatch.rs @@ -792,10 +792,7 @@ impl CdpConnection { // for the navigation's Page adoption. if command.renderer_access() == CdpRendererCommandAccess::OwnerIndependent || (command.can_use_prepared_inspector_endpoint() - && slot - .page_slot() - .prepared_document_inspector_endpoint() - .is_some()) + && slot.inspector_endpoint_before_adoption().is_some()) { return None; } diff --git a/moli-protocol/src/conn/runtime_eval/protocol_dispatch.rs b/moli-protocol/src/conn/runtime_eval/protocol_dispatch.rs index e651723974b..cb6bdd6d508 100644 --- a/moli-protocol/src/conn/runtime_eval/protocol_dispatch.rs +++ b/moli-protocol/src/conn/runtime_eval/protocol_dispatch.rs @@ -46,6 +46,28 @@ impl CdpConnection { } } + fn inspector_command_route_for_owner( + &self, + owner: &CommandOwnerScope, + inspector_route: RendererInspectorCommandRoute, + ) -> Option<( + RuntimeProtocolMessagePageRoute, + Option, + )> { + let mut route = self.runtime_protocol_message_page_route_for_owner(owner)?; + let endpoint = if inspector_route == RendererInspectorCommandRoute::Io { + let slot = self.runtime_session_owner_slot_for_owner(owner)?; + let endpoint = slot.current_inspector_endpoint()?; + route.renderer_agent_attachment_id = slot + .renderer_output_attachment_for_agent(endpoint.agent())? + .id(); + Some(endpoint) + } else { + None + }; + Some((route, endpoint)) + } + pub(crate) fn start_runtime_protocol_message_for_owner( &mut self, owner: &CommandOwnerScope, @@ -76,17 +98,13 @@ impl CdpConnection { raw_json: String, inspector_route: RendererInspectorCommandRoute, ) -> Result { - let route = self - .runtime_protocol_message_page_route_for_owner(owner) + let (route, endpoint) = self + .inspector_command_route_for_owner(owner, inspector_route) .context(NoDocumentLoaded)?; let raw_json = self.rewrite_runtime_inspector_command_for_owner(owner, &raw_json, None)?; let inspector_session_id = self.target_renderer_runtime_inspector_session_id_for_owner(owner); - if inspector_route == RendererInspectorCommandRoute::Io - && let Some(endpoint) = self - .runtime_session_owner_slot_for_owner(owner) - .and_then(|slot| slot.page_slot().prepared_document_inspector_endpoint()) - { + if let Some(endpoint) = endpoint { let pending = moli_core::page::PendingRuntimeInspectorCommandDispatch::start_io( &endpoint, route.renderer_agent_attachment_id, @@ -101,26 +119,11 @@ impl CdpConnection { response_route: RuntimeProtocolResponseRoute::adapter_reply_without_receiver(), }); } - let page = match inspector_route { - RendererInspectorCommandRoute::MainThread => { - self.loaded_page_mut_for_protocol_access_for_owner(owner)? - } - RendererInspectorCommandRoute::Io => self - .loaded_page_mut_for_owner(owner) - .context(NoDocumentLoaded)?, - }; - let pending = match inspector_route { - RendererInspectorCommandRoute::MainThread => page - .start_runtime_protocol_message_for_inspector_session( - inspector_session_id, - raw_json, - ) - .map(PendingRuntimeProtocolMessageDispatchKind::Page), - RendererInspectorCommandRoute::Io => page - .start_runtime_inspector_io_message_without_response(inspector_session_id, raw_json) - .map(PendingRuntimeProtocolMessageDispatchKind::Routable), - } - .context("runtime inspector dispatch failed")?; + let page = self.loaded_page_mut_for_protocol_access_for_owner(owner)?; + let pending = page + .start_runtime_protocol_message_for_inspector_session(inspector_session_id, raw_json) + .map(PendingRuntimeProtocolMessageDispatchKind::Page) + .context("runtime inspector dispatch failed")?; Ok(PendingRuntimeProtocolMessageDispatch { owner: owner.clone(), route, @@ -164,8 +167,8 @@ impl CdpConnection { command_id: u64, inspector_route: RendererInspectorCommandRoute, ) -> Result { - let route = self - .runtime_protocol_message_page_route_for_owner(owner) + let (route, endpoint) = self + .inspector_command_route_for_owner(owner, inspector_route) .context(NoDocumentLoaded)?; let (correlation, raw_json, response_sender, response_route) = self .prepare_renderer_call_for_owner( @@ -176,11 +179,7 @@ impl CdpConnection { )?; let inspector_session_id = self.target_renderer_runtime_inspector_session_id_for_owner(owner); - if inspector_route == RendererInspectorCommandRoute::Io - && let Some(endpoint) = self - .runtime_session_owner_slot_for_owner(owner) - .and_then(|slot| slot.page_slot().prepared_document_inspector_endpoint()) - { + if let Some(endpoint) = endpoint { let pending = moli_core::page::PendingRuntimeInspectorCommandDispatch::start_io( &endpoint, route.renderer_agent_attachment_id, @@ -195,14 +194,7 @@ impl CdpConnection { response_route, }); } - let page_result = match inspector_route { - RendererInspectorCommandRoute::MainThread => { - self.loaded_page_mut_for_protocol_access_for_owner(owner) - } - RendererInspectorCommandRoute::Io => self - .loaded_page_mut_for_owner(owner) - .context(NoDocumentLoaded), - }; + let page_result = self.loaded_page_mut_for_protocol_access_for_owner(owner); let page = match page_result { Ok(page) => page, Err(error) => { diff --git a/moli-protocol/src/conn/state/runtime_slot.rs b/moli-protocol/src/conn/state/runtime_slot.rs index bc85dde6cbb..ad0b99fefd9 100644 --- a/moli-protocol/src/conn/state/runtime_slot.rs +++ b/moli-protocol/src/conn/state/runtime_slot.rs @@ -154,11 +154,21 @@ impl TargetRuntimeSlot { &mut self.page_slot } + pub(crate) fn inspector_endpoint_before_adoption( + &self, + ) -> Option { + // An outgoing Document can pause in a pagehide or unload handler + // after the replacement's endpoint has been admitted. + self.loaded_page() + .map(Page::inspector_endpoint) + .filter(moli_core::page::RendererPageInspectorEndpoint::has_announced_pause) + .or_else(|| self.page_slot.prepared_document_inspector_endpoint()) + } + pub(crate) fn current_inspector_endpoint( &self, ) -> Option { - self.page_slot - .prepared_document_inspector_endpoint() + self.inspector_endpoint_before_adoption() .or_else(|| self.loaded_page().map(Page::inspector_endpoint)) } diff --git a/moli-renderer-v8/src/devtools/command.rs b/moli-renderer-v8/src/devtools/command.rs index 8576be47782..e8dbc715032 100644 --- a/moli-renderer-v8/src/devtools/command.rs +++ b/moli-renderer-v8/src/devtools/command.rs @@ -281,6 +281,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 f3042afd1df..e1406c49c7b 100644 --- a/moli-renderer-v8/src/devtools/command/nested.rs +++ b/moli-renderer-v8/src/devtools/command/nested.rs @@ -6,12 +6,14 @@ use crate::runtime::{RendererDevToolsPageCommand, RendererPageCommand}; impl RendererPageCommand { pub(crate) fn nested_dispatch(&self) -> RendererDevToolsMainNestedDispatch { - use RendererDevToolsMainNestedDispatch::{OwnerOnly, PageAgent}; + use RendererDevToolsMainNestedDispatch::{BeforeUnload, OwnerOnly, PageAgent}; match self { #[cfg(feature = "ace-protocol")] Self::AcePageTask(..) => OwnerOnly, Self::ForDocument { command, .. } => command.nested_dispatch(), Self::DevTools(command) => command.nested_dispatch(), + // The pause callback already has the V8 scope entered for beforeunload. + 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 @@ -67,7 +69,6 @@ impl RendererPageCommand { | Self::RuntimeConsoleMessagesWithContext | Self::RuntimeHeapUsage | Self::StopDocumentLifecycle - | Self::CheckMainDocumentBeforeUnload | Self::UnloadMainDocumentForNavigationCommit | Self::ResetNavigationHistory | Self::RenderMarkdown { .. } diff --git a/moli-renderer-v8/src/devtools/ingress/main.rs b/moli-renderer-v8/src/devtools/ingress/main.rs index e73f38303e9..afebc9dc391 100644 --- a/moli-renderer-v8/src/devtools/ingress/main.rs +++ b/moli-renderer-v8/src/devtools/ingress/main.rs @@ -131,6 +131,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 @@ -633,20 +645,27 @@ 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().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| { @@ -654,7 +673,11 @@ impl RendererInspectorMainIngress { || command.envelope.is_session_connection() || command.connection.ready()) && (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 { @@ -664,7 +687,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 => { @@ -966,7 +990,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()), @@ -1004,13 +1028,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""#)); } @@ -1100,7 +1124,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(), @@ -1222,7 +1246,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 @@ -1316,14 +1340,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" ); @@ -1337,7 +1361,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(), @@ -1358,7 +1382,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(), @@ -1373,7 +1397,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(), @@ -1398,7 +1422,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/frontend.rs b/moli-renderer-v8/src/devtools/pause/frontend.rs index 8f5d2b5afa3..aa065fe01a5 100644 --- a/moli-renderer-v8/src/devtools/pause/frontend.rs +++ b/moli-renderer-v8/src/devtools/pause/frontend.rs @@ -24,6 +24,8 @@ pub(super) struct PauseState { pause_loop_policy: RendererInspectorPauseLoopPolicy, quit_requested: bool, session_detach_arms: usize, + terminate_replacement_pause: bool, + replacement_pauses_awaiting_resumed: HashSet<(RendererDevToolsAgentToken, DevToolsSessionKey)>, pub(super) pending_prefaces: VecDeque, pub(super) paused_sessions_awaiting_resumed: HashSet<(RendererDevToolsAgentToken, DevToolsSessionKey)>, @@ -44,6 +46,8 @@ impl Default for PauseState { pause_loop_policy: RendererInspectorPauseLoopPolicy::MainAndIo, quit_requested: false, session_detach_arms: 0, + terminate_replacement_pause: false, + replacement_pauses_awaiting_resumed: HashSet::new(), pending_prefaces: VecDeque::new(), paused_sessions_awaiting_resumed: HashSet::new(), active_command_dispatch: None, @@ -90,19 +94,25 @@ impl PauseState { self.quit_requested = true; self.pending_prefaces.clear(); self.paused_sessions_awaiting_resumed.clear(); + self.replacement_pauses_awaiting_resumed.clear(); self.finish_owner_turn(); } pub(super) fn detach_page(&mut self) -> bool { self.pending_prefaces.clear(); self.paused_sessions_awaiting_resumed.clear(); + self.replacement_pauses_awaiting_resumed.clear(); self.finish_owner_turn(); match self.phase { - RendererInspectorPausePhase::Running => false, + RendererInspectorPausePhase::Running => { + self.terminate_replacement_pause = false; + false + } RendererInspectorPausePhase::Entering => { self.phase = RendererInspectorPausePhase::Running; self.pause_loop_policy = RendererInspectorPauseLoopPolicy::MainAndIo; self.quit_requested = false; + self.terminate_replacement_pause = false; false } RendererInspectorPausePhase::Paused => { @@ -364,7 +374,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.frontend.terminate_replacement_pause + { return Err(RendererInspectorPauseExitReason::DocumentReplacement); } if state.frontend.session_detach_arms != 0 { @@ -393,6 +405,7 @@ impl RendererInspectorPauseBridge { state.frontend.phase = RendererInspectorPausePhase::Running; state.frontend.pause_loop_policy = RendererInspectorPauseLoopPolicy::MainAndIo; state.frontend.quit_requested = false; + state.frontend.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. @@ -447,6 +460,17 @@ impl RendererInspectorPauseBridge { { return RendererInspectorPauseNotificationRoute::Drop; } + if is_resumed_notification + && state + .frontend + .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.frontend.terminate_replacement_pause); let preface = if is_paused_notification { state .frontend @@ -461,7 +485,7 @@ impl RendererInspectorPauseBridge { } else { Vec::new() }; - if is_paused_notification { + if is_paused_notification && !replacement_pause { state .frontend .paused_sessions_awaiting_resumed @@ -512,6 +536,17 @@ impl RendererInspectorPauseBridge { state.frontend.pause_loop_policy = RendererInspectorPauseLoopPolicy::IoOnly; } } + if replacement_pause { + // The old document can pause again during commit. Publish its + // preceding output and retain the decision to end the pause even + // if the replacement is cancelled before V8 enters the loop. + state.frontend.terminate_replacement_pause = true; + state + .frontend + .replacement_pauses_awaiting_resumed + .insert(session_route); + return RendererInspectorPauseNotificationRoute::PublishPrefix { preface }; + } if state.frontend.phase == RendererInspectorPausePhase::Running && !resumes_reported_pause { RendererInspectorPauseNotificationRoute::OrdinaryTurn } else { @@ -532,6 +567,10 @@ impl RendererInspectorPauseBridge { .frontend .paused_sessions_awaiting_resumed .remove(&(agent_token, session.clone())); + state + .frontend + .replacement_pauses_awaiting_resumed + .remove(&(agent_token, session.clone())); state .frontend .pending_prefaces diff --git a/moli-renderer-v8/src/devtools/pause/mod.rs b/moli-renderer-v8/src/devtools/pause/mod.rs index 0ae163ca121..0dd8fa40976 100644 --- a/moli-renderer-v8/src/devtools/pause/mod.rs +++ b/moli-renderer-v8/src/devtools/pause/mod.rs @@ -41,12 +41,28 @@ struct RendererInspectorPauseRoute { struct RendererInspectorPauseBridgeState { document_replacements: usize, + unload_callbacks: usize, target_closed: bool, route: Option, #[cfg(feature = "devtools")] frontend: frontend::PauseState, } +#[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, @@ -81,6 +97,7 @@ impl RendererInspectorPauseBridge { let shared = Arc::new(RendererInspectorPauseBridgeShared { state: Mutex::new(RendererInspectorPauseBridgeState { document_replacements: 0, + unload_callbacks: 0, target_closed: false, route: None, #[cfg(feature = "devtools")] @@ -131,6 +148,20 @@ impl RendererInspectorPauseBridge { } } + #[cfg(feature = "devtools")] + pub(crate) fn has_announced_pause_for_agent( + &self, + agent: moli_page_types::RendererDevToolsAgentToken, + ) -> bool { + self.shared + .state + .lock() + .frontend + .paused_sessions_awaiting_resumed + .iter() + .any(|(owner, _)| *owner == agent) + } + /// Ends the bounded handoff from a resume/step command to the renderer turn /// it released. A step that reaches the end of its task may never enter a /// new pause; owner settlement is the terminal that prevents its cause from @@ -150,6 +181,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 diff --git a/moli-renderer-v8/src/devtools/pause/tests.rs b/moli-renderer-v8/src/devtools/pause/tests.rs index c85b77590e4..3b8a4e7e80a 100644 --- a/moli-renderer-v8/src/devtools/pause/tests.rs +++ b/moli-renderer-v8/src/devtools/pause/tests.rs @@ -85,6 +85,74 @@ 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: moli_inspector_json::InspectorJson = + json!({"method": "Debugger.paused", "params": {"callFrames": []}}).into(); + let resumed: moli_inspector_json::InspectorJson = + json!({"method": "Debugger.resumed", "params": {}}).into(); + 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 d688f9f4209..0702ae475c6 100644 --- a/moli-renderer-v8/src/runtime/mod.rs +++ b/moli-renderer-v8/src/runtime/mod.rs @@ -547,7 +547,10 @@ pub(crate) use crate::service_worker_runtime::{ service_worker_exposed_client_id, }; #[cfg(feature = "devtools")] -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.rs b/moli-renderer-v8/src/runtime/owner_local.rs index 49bd987f756..7a7d37ff90a 100644 --- a/moli-renderer-v8/src/runtime/owner_local.rs +++ b/moli-renderer-v8/src/runtime/owner_local.rs @@ -392,6 +392,12 @@ impl RendererPageInspectorEndpoint { self.agent } + pub fn has_announced_pause(&self) -> bool { + self.target + .pause_ref() + .has_announced_pause_for_agent(self.agent) + } + pub fn has_session(&self, id: Option<&str>) -> bool { self.target.io_ref().session_connections().contains( &crate::devtools::ingress::lane::RendererDevToolsSessionLaneKey::new( 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 a0f9d2d3352..8176c6a1d7f 100644 --- a/moli-renderer-v8/src/runtime/owner_local_store/bound.rs +++ b/moli-renderer-v8/src/runtime/owner_local_store/bound.rs @@ -289,7 +289,17 @@ 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| { + #[cfg(feature = "devtools")] + { + crate::runtime::nested_main::scope_active_nested_main_page(entry, operation) + } + #[cfg(not(feature = "devtools"))] + { + operation(entry) + } + }) + .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 c16ee0bef8f..7f864f77276 100644 --- a/moli-renderer-v8/src/runtime/owner_local_store/mod.rs +++ b/moli-renderer-v8/src/runtime/owner_local_store/mod.rs @@ -2770,8 +2770,6 @@ impl RendererOwnerLocalStore { .document_replacement_lifecycle_action_snapshot(); let command_epoch = Self::advance_command_epoch(entry); let slot = entry.slot.clone(); - #[cfg(feature = "devtools")] - 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 d8b329dec07..48152daa70d 100644 --- a/moli-renderer-v8/src/script_vm/child_frame_runtime.rs +++ b/moli-renderer-v8/src/script_vm/child_frame_runtime.rs @@ -537,7 +537,28 @@ impl ScriptVm { }) } + #[cfg(feature = "devtools")] + 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| { PageScriptHost::dispatch_main_document_unload_for_navigation_commit(scope, host_ptr); Ok(()) diff --git a/moli-renderer-v8/src/script_vm/inspector/frontend/reply_routing.rs b/moli-renderer-v8/src/script_vm/inspector/frontend/reply_routing.rs index 78c62ae6f1a..cbd475af724 100644 --- a/moli-renderer-v8/src/script_vm/inspector/frontend/reply_routing.rs +++ b/moli-renderer-v8/src/script_vm/inspector/frontend/reply_routing.rs @@ -184,7 +184,7 @@ impl InspectorOutbound { &self, mut preface: Vec, command_output: Option, - value: InspectorJson, + value: Option, ) { let session = self .session @@ -207,9 +207,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), @@ -247,7 +256,10 @@ impl InspectorOutbound { RendererInspectorPauseNotificationRoute::PublishImmediately { preface, command_output, - } => self.publish_pause_value(preface, command_output, value), + } => self.publish_pause_value(preface, command_output, Some(value)), + RendererInspectorPauseNotificationRoute::PublishPrefix { preface } => { + self.publish_pause_value(preface, None, None); + } RendererInspectorPauseNotificationRoute::Drop => {} } } 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 1aa4e0e8df1..420b11d0a91 100644 --- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs +++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs @@ -28,8 +28,6 @@ use crate::inspector_microtasks::with_scoped_inspector_microtasks; #[cfg(feature = "devtools")] use crate::inspector_session::InspectorSessionOutput; #[cfg(feature = "devtools")] -use crate::runtime::dispatch_nested_main_page_command; -#[cfg(feature = "devtools")] use crate::runtime::{ RendererDevToolsIoCommandKind, RendererDevToolsIoCommandPayload, RendererDevToolsMainNestedDispatch, @@ -39,6 +37,11 @@ use crate::runtime::{ RendererOwnerReply, RendererPageCommand, RendererRuntimeCommandOutput, RendererRuntimeInspectorMessage, RendererRuntimeInspectorResponseSender, }; +#[cfg(feature = "devtools")] +use crate::runtime::{ + dispatch_nested_main_beforeunload, dispatch_nested_main_page_command, + nested_main_beforeunload_is_allowed, +}; pub(crate) use interrupt::dispatch_inspector_io_owner_wake; #[cfg(feature = "devtools")] pub(crate) use interrupt::dispatch_inspector_main_owner_wake; @@ -240,7 +243,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 @@ -257,7 +260,7 @@ impl RendererInspectorSessionExecutorLocal { .or_else(|| { self.target .main_ref() - .claim_for_pause() + .claim_for_pause(nested_main_beforeunload_is_allowed()) .map(RendererInspectorNestedCommand::Main) }), }; @@ -334,6 +337,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();