mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 00:03:15 +00:00
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.
This commit is contained in:
@@ -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",
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
use super::*;
|
||||
|
||||
mod beforeunload;
|
||||
mod superseded_interception;
|
||||
|
||||
type TestSocket =
|
||||
|
||||
+214
@@ -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, "<title>replacement</title>")
|
||||
};
|
||||
(
|
||||
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,<title>old</title><iframe srcdoc='<p>child</p>'></iframe>",
|
||||
)
|
||||
.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::<Vec<_>>();
|
||||
let consoles = messages
|
||||
.iter()
|
||||
.filter(|message| message["method"] == "Runtime.consoleAPICalled")
|
||||
.map(|message| message["params"]["args"][0]["value"].clone())
|
||||
.collect::<Vec<_>>();
|
||||
// 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
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -46,6 +46,28 @@ impl CdpConnection {
|
||||
}
|
||||
}
|
||||
|
||||
fn inspector_command_route_for_owner(
|
||||
&self,
|
||||
owner: &CommandOwnerScope,
|
||||
inspector_route: RendererInspectorCommandRoute,
|
||||
) -> Option<(
|
||||
RuntimeProtocolMessagePageRoute,
|
||||
Option<moli_core::page::RendererPageInspectorEndpoint>,
|
||||
)> {
|
||||
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<PendingRuntimeProtocolMessageDispatch> {
|
||||
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<PendingRuntimeProtocolMessageDispatch> {
|
||||
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) => {
|
||||
|
||||
@@ -154,11 +154,21 @@ impl TargetRuntimeSlot {
|
||||
&mut self.page_slot
|
||||
}
|
||||
|
||||
pub(crate) fn inspector_endpoint_before_adoption(
|
||||
&self,
|
||||
) -> Option<moli_core::page::RendererPageInspectorEndpoint> {
|
||||
// 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<moli_core::page::RendererPageInspectorEndpoint> {
|
||||
self.page_slot
|
||||
.prepared_document_inspector_endpoint()
|
||||
self.inspector_endpoint_before_adoption()
|
||||
.or_else(|| self.loaded_page().map(Page::inspector_endpoint))
|
||||
}
|
||||
|
||||
|
||||
@@ -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,
|
||||
}
|
||||
|
||||
|
||||
@@ -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 { .. }
|
||||
|
||||
@@ -131,6 +131,18 @@ impl RendererInspectorMainCommand {
|
||||
(command, reply_tx)
|
||||
}
|
||||
|
||||
pub(crate) fn into_nested_beforeunload_reply(
|
||||
self,
|
||||
) -> tokio::sync::oneshot::Sender<anyhow::Result<RendererOwnerReply>> {
|
||||
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<RendererInspectorMainCommandConsumer> {
|
||||
self.claimed_by
|
||||
@@ -633,20 +645,27 @@ impl RendererInspectorMainIngress {
|
||||
|
||||
pub(crate) fn claim_for_owner(&self) -> Option<RendererInspectorMainCommand> {
|
||||
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<RendererInspectorMainCommand> {
|
||||
self.claim_next(RendererInspectorMainCommandConsumer::Pause)
|
||||
pub(crate) fn claim_for_pause(
|
||||
&self,
|
||||
beforeunload_allowed: bool,
|
||||
) -> Option<RendererInspectorMainCommand> {
|
||||
self.claim_next(
|
||||
RendererInspectorMainCommandConsumer::Pause,
|
||||
beforeunload_allowed,
|
||||
)
|
||||
}
|
||||
|
||||
fn claim_next(
|
||||
&self,
|
||||
consumer: RendererInspectorMainCommandConsumer,
|
||||
beforeunload_allowed: bool,
|
||||
) -> Option<RendererInspectorMainCommand> {
|
||||
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");
|
||||
|
||||
@@ -73,6 +73,9 @@ pub(super) struct RendererInspectorPausePreface {
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub(crate) enum RendererInspectorPauseNotificationRoute {
|
||||
OrdinaryTurn,
|
||||
PublishPrefix {
|
||||
preface: Vec<RendererRuntimeInspectorMessage>,
|
||||
},
|
||||
PublishImmediately {
|
||||
preface: Vec<RendererRuntimeInspectorMessage>,
|
||||
command_output: Option<RendererInspectorPauseCommandOutputRoute>,
|
||||
|
||||
@@ -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<RendererInspectorPausePreface>,
|
||||
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
|
||||
|
||||
@@ -41,12 +41,28 @@ struct RendererInspectorPauseRoute {
|
||||
|
||||
struct RendererInspectorPauseBridgeState {
|
||||
document_replacements: usize,
|
||||
unload_callbacks: usize,
|
||||
target_closed: bool,
|
||||
route: Option<RendererInspectorPauseRoute>,
|
||||
#[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<RendererInspectorPauseBridgeShared>,
|
||||
@@ -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
|
||||
|
||||
@@ -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,
|
||||
) -> (
|
||||
|
||||
@@ -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);
|
||||
|
||||
|
||||
@@ -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<ActiveNestedMainPage>,
|
||||
_owner_local: PhantomData<Rc<()>>,
|
||||
}
|
||||
@@ -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<Box<dyn Future<Output = Result<R>> + 'a>>,
|
||||
) -> Pin<Box<dyn Future<Output = Result<R>> + '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<ActiveNestedMainPage> {
|
||||
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<RendererCommandTurnOutput> {
|
||||
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<RendererCommandTurnOutput> {
|
||||
// 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.
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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(())
|
||||
|
||||
@@ -184,7 +184,7 @@ impl InspectorOutbound {
|
||||
&self,
|
||||
mut preface: Vec<RendererRuntimeInspectorMessage>,
|
||||
command_output: Option<crate::devtools::pause::RendererInspectorPauseCommandOutputRoute>,
|
||||
value: InspectorJson,
|
||||
value: Option<InspectorJson>,
|
||||
) {
|
||||
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 => {}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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();
|
||||
|
||||
Reference in New Issue
Block a user