From e5a98c0fa90f2ff4c1b47df7c304ea755be9aaed 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 | 214 ++++++++++++++++++ moli-protocol/src/conn/dispatch.rs | 5 +- .../conn/runtime_eval/protocol_dispatch.rs | 76 +++---- moli-protocol/src/conn/state/runtime_slot.rs | 14 +- moli-renderer-v8/src/devtools/command.rs | 1 + .../src/devtools/command/nested.rs | 5 +- moli-renderer-v8/src/devtools/ingress/main.rs | 56 +++-- .../src/devtools/pause/causality.rs | 3 + .../src/devtools/pause/frontend.rs | 45 +++- moli-renderer-v8/src/devtools/pause/mod.rs | 45 ++++ moli-renderer-v8/src/devtools/pause/tests.rs | 68 ++++++ moli-renderer-v8/src/runtime/mod.rs | 5 +- moli-renderer-v8/src/runtime/nested_main.rs | 84 +++++-- moli-renderer-v8/src/runtime/owner_local.rs | 6 + .../src/runtime/owner_local_store/bound.rs | 12 +- .../src/runtime/owner_local_store/mod.rs | 2 - .../src/script_vm/child_frame_runtime.rs | 21 ++ .../inspector/frontend/reply_routing.rs | 22 +- .../src/script_vm/inspector/v8_backend.rs | 26 ++- 21 files changed, 628 insertions(+), 100 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 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();