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