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