Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(devtools): unblock navigation while the debugger is paused

ldm079ea1406fa9a
diff --git a/moli-core/src/page/js_evaluation.rs b/moli-core/src/page/js_evaluation.rs
index df6641c64..b744f3f7e 100644
--- a/moli-core/src/page/js_evaluation.rs
+++ b/moli-core/src/page/js_evaluation.rs
@@ -594,6 +594,11 @@ impl Page {
self.handle.runtime_inspector_pause_active()
}
+ #[doc(hidden)]
+ pub fn renderer_devtools_target(&self) -> super::RendererDevToolsTargetHandle {
+ self.handle.renderer_devtools_target()
+ }
+
pub fn start_runtime_protocol_message_with_context_resolution(
&self,
action: String,
diff --git a/moli-core/src/page/mod.rs b/moli-core/src/page/mod.rs
index c0ef0acd6..11b3a6187 100644
--- a/moli-core/src/page/mod.rs
+++ b/moli-core/src/page/mod.rs
@@ -91,12 +91,13 @@ pub use moli_renderer_v8::{
RendererCaptureScreencastFrameReply, RendererCaptureScreencastFrameRequest,
RendererCaptureScreenshotReply, RendererCaptureScreenshotRequest,
RendererCommandTurnCompletion, RendererCommandTurnOutput, RendererDedicatedWorkerTargetEvent,
- RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken, RendererDocumentHitTestResult,
- RendererDocumentIsolateAccountingDiagnostics, RendererDocumentLifecycleEvent,
- RendererDocumentLifecycleEventKind, RendererDocumentLifecycleIdentity,
- RendererDocumentLifecycleMilestone, RendererDocumentLifecycleSnapshot,
- RendererDocumentLifecycleWaitOutcome, RendererDocumentLifecycleWaiter,
- RendererDocumentNodeGeometry, RendererDocumentSourcedSameDocumentNavigation,
+ RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken, RendererDevToolsTargetHandle,
+ RendererDocumentHitTestResult, RendererDocumentIsolateAccountingDiagnostics,
+ RendererDocumentLifecycleEvent, RendererDocumentLifecycleEventKind,
+ RendererDocumentLifecycleIdentity, RendererDocumentLifecycleMilestone,
+ RendererDocumentLifecycleSnapshot, RendererDocumentLifecycleWaitOutcome,
+ RendererDocumentLifecycleWaiter, RendererDocumentNodeGeometry,
+ RendererDocumentSourcedSameDocumentNavigation,
RendererDocumentSourcedTopLevelLocationNavigation, RendererDocumentTerminationReason,
RendererDocumentToken, RendererDomAttributeMutation, RendererDomAttributeMutationOutcome,
RendererDomDebuggerDomBreakpointResolution, RendererDomDebuggerEventListener,
diff --git a/moli-protocol-server/src/protocol_server/tests/websocket.rs b/moli-protocol-server/src/protocol_server/tests/websocket.rs
index 6b46d694c..6cad96951 100644
--- a/moli-protocol-server/src/protocol_server/tests/websocket.rs
+++ b/moli-protocol-server/src/protocol_server/tests/websocket.rs
@@ -1,6 +1,8 @@
use super::*;
use std::path::Path;
+mod navigation_debugger;
+
fn assert_cdp_event_precedes_response(
messages: &[serde_json::Value],
method: &str,
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
new file mode 100644
index 000000000..6b4f68bf6
--- /dev/null
+++ b/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger.rs
@@ -0,0 +1,514 @@
+use super::*;
+
+type TestSocket =
+ tokio_tungstenite::WebSocketStream<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>>;
+
+const NAVIGATION_TIMEOUT: Duration = Duration::from_secs(30);
+
+async fn pause_in_timer(
+ socket: &mut TestSocket,
+ session_id: &str,
+ id: u64,
+ body: &str,
+) -> Vec<serde_json::Value> {
+ let mut messages = send_cdp_command(
+ socket,
+ id,
+ "Runtime.evaluate",
+ Some(session_id),
+ json!({"expression": format!("setTimeout(() => {{ {body} }}, 0); 'armed'")}),
+ )
+ .await;
+ if !messages
+ .iter()
+ .any(|message| message["method"] == "Debugger.paused" && message["sessionId"] == session_id)
+ {
+ messages.extend(
+ recv_until_match(socket, |message| {
+ message["method"] == "Debugger.paused" && message["sessionId"] == session_id
+ })
+ .await,
+ );
+ }
+ assert!(
+ messages.iter().any(|message| {
+ message["id"] == id && message["result"]["result"]["value"] == "armed"
+ })
+ );
+ messages
+}
+
+async fn assert_navigation_exits_debugger_pause(body: &str, second_frontend: bool) {
+ let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
+ let (mut socket, _) = connect_async(format!(
+ "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
+ ))
+ .await
+ .expect("connect to cdp websocket");
+ let session_id = cdp_create_default_session_and_navigate(
+ &mut socket,
+ "data:text/html,<title>old document</title>",
+ )
+ .await;
+ send_cdp_command(
+ &mut socket,
+ 6,
+ "Debugger.enable",
+ Some(&session_id),
+ json!({}),
+ )
+ .await;
+ let second_session = if second_frontend {
+ let tree = send_cdp_command(
+ &mut socket,
+ 20,
+ "Page.getFrameTree",
+ Some(&session_id),
+ json!({}),
+ )
+ .await;
+ let tree_reply = tree
+ .iter()
+ .find(|message| message["id"] == 20)
+ .expect("frame tree response");
+ let target_id = &tree_reply["result"]["frameTree"]["frame"]["id"];
+ let attached = send_cdp_command(
+ &mut socket,
+ 21,
+ "Target.attachToTarget",
+ None,
+ json!({"targetId": target_id, "flatten": true}),
+ )
+ .await;
+ let second_session = attached.iter().find(|message| message["id"] == 21).unwrap()["result"]
+ ["sessionId"]
+ .as_str()
+ .unwrap();
+ send_cdp_command(
+ &mut socket,
+ 22,
+ "Debugger.enable",
+ Some(second_session),
+ json!({}),
+ )
+ .await;
+ Some(second_session.to_owned())
+ } else {
+ None
+ };
+ let paused = pause_in_timer(&mut socket, &session_id, 7, body).await;
+ if let Some(second_session) = second_session
+ && !paused.iter().any(|message| {
+ message["method"] == "Debugger.paused" && message["sessionId"] == second_session
+ })
+ {
+ recv_until_match(&mut socket, |message| {
+ message["method"] == "Debugger.paused" && message["sessionId"] == second_session
+ })
+ .await;
+ }
+
+ let destination = "data:text/html,<title>replacement</title>";
+ let navigation = timeout(
+ NAVIGATION_TIMEOUT,
+ cdp_navigate_and_wait_for_load(&mut socket, 8, &session_id, destination),
+ )
+ .await;
+ // Release the old execution before failing, so a regression cannot leave
+ // the test renderer's owner thread in its nested pause loop during cleanup.
+ if navigation.is_err() {
+ send_cdp_command(
+ &mut socket,
+ 90,
+ "Debugger.resume",
+ Some(&session_id),
+ json!({"terminateOnResume": true}),
+ )
+ .await;
+ let _ = socket.close(None).await;
+ abort_test_cdp_server(protocol_server).await;
+ panic!("cross-document navigation must terminate paused old-document execution");
+ }
+ let messages = navigation.unwrap();
+ assert!(messages.iter().any(|message| {
+ message["method"] == "Page.frameNavigated"
+ && message["params"]["frame"]["url"] == destination
+ }));
+ assert!(
+ !messages
+ .iter()
+ .any(|message| message["method"] == "Debugger.paused")
+ );
+ assert_eq!(
+ cdp_runtime_evaluate_string(&mut socket, &session_id, 9, "document.title").await,
+ "replacement"
+ );
+
+ // Navigation must not disable debugging in the replacement inspector
+ // session. No second Debugger.enable is sent.
+ pause_in_timer(&mut socket, &session_id, 10, "debugger;").await;
+ send_cdp_command(
+ &mut socket,
+ 11,
+ "Debugger.resume",
+ Some(&session_id),
+ json!({}),
+ )
+ .await;
+ let _ = socket.close(None).await;
+ abort_test_cdp_server(protocol_server).await;
+}
+
+#[tokio::test]
+async fn navigation_terminates_single_debugger_pause() {
+ assert_navigation_exits_debugger_pause("debugger;", false).await;
+}
+
+#[tokio::test]
+async fn navigation_terminates_repeated_debugger_pauses() {
+ assert_navigation_exits_debugger_pause("for (;;) { debugger; }", false).await;
+}
+
+#[tokio::test]
+async fn navigation_terminates_pause_with_multiple_debugger_sessions() {
+ assert_navigation_exits_debugger_pause("for (;;) { debugger; }", true).await;
+}
+
+#[tokio::test]
+async fn navigation_terminates_pauses_from_repeating_timers() {
+ assert_navigation_exits_debugger_pause("setInterval(() => { debugger; }, 0); debugger;", false)
+ .await;
+}
+
+#[tokio::test]
+async fn navigation_terminates_pause_only_when_document_response_is_ready() {
+ assert_delayed_navigation_while_paused(false).await;
+}
+
+#[tokio::test]
+async fn navigation_supersedes_a_delayed_response_while_debugger_is_paused() {
+ assert_delayed_navigation_while_paused(true).await;
+}
+
+async fn assert_delayed_navigation_while_paused(supersede: bool) {
+ let requested = Arc::new(tokio::sync::Notify::new());
+ let release_response = Arc::new(tokio::sync::Notify::new());
+ let fixture_listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let fixture_addr = fixture_listener.local_addr().unwrap();
+ let app = axum::Router::new().route(
+ "/",
+ axum::routing::get({
+ let requested = requested.clone();
+ let release_response = release_response.clone();
+ move || {
+ let requested = requested.clone();
+ let release_response = release_response.clone();
+ async move {
+ requested.notify_one();
+ release_response.notified().await;
+ axum::response::Html("<title>HTTP replacement</title>")
+ }
+ }
+ }),
+ );
+ let fixture = tokio::spawn(async move { axum::serve(fixture_listener, app).await.unwrap() });
+ let (cdp_addr, protocol_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,<title>old</title>")
+ .await;
+ send_cdp_command(
+ &mut socket,
+ 6,
+ "Debugger.enable",
+ Some(&session_id),
+ json!({}),
+ )
+ .await;
+ pause_in_timer(&mut socket, &session_id, 7, "for (;;) { debugger; }").await;
+ send_cdp_command_without_wait(
+ &mut socket,
+ 8,
+ "Page.navigate",
+ Some(&session_id),
+ json!({"url": format!("http://{fixture_addr}/")}),
+ )
+ .await;
+ timeout(NAVIGATION_TIMEOUT, requested.notified())
+ .await
+ .unwrap();
+
+ let mut navigated = if supersede {
+ timeout(
+ NAVIGATION_TIMEOUT,
+ cdp_navigate_and_wait_for_load(
+ &mut socket,
+ 9,
+ &session_id,
+ "data:text/html,<title>second replacement</title>",
+ ),
+ )
+ .await
+ } else {
+ // A response that has not arrived must not terminate the old document.
+ // Successful resume proves it is still paused. The loop immediately
+ // hits another debugger statement; its event may be navigation-gated.
+ let resumed = send_cdp_command(
+ &mut socket,
+ 9,
+ "Debugger.resume",
+ Some(&session_id),
+ json!({}),
+ )
+ .await;
+ assert!(
+ resumed
+ .iter()
+ .any(|message| { message["id"] == 9 && message.get("error").is_none() })
+ );
+ release_response.notify_one();
+ timeout(
+ NAVIGATION_TIMEOUT,
+ recv_until_match(&mut socket, |message| {
+ message["method"] == "Page.loadEventFired"
+ }),
+ )
+ .await
+ };
+ if navigated.is_err() {
+ send_cdp_command(
+ &mut socket,
+ 90,
+ "Debugger.resume",
+ Some(&session_id),
+ json!({"terminateOnResume": true}),
+ )
+ .await;
+ }
+ if supersede && let Ok(messages) = &mut navigated {
+ if !messages.iter().any(|message| message["id"] == 8) {
+ messages.extend(recv_until_id(&mut socket, 8).await);
+ }
+ let aborted = messages
+ .iter()
+ .find(|message| message["id"] == 8)
+ .expect("superseded navigation must receive a terminal response");
+ assert!(aborted.get("error").is_none());
+ assert_eq!(aborted["result"]["errorText"], "net::ERR_ABORTED");
+ // The replacement must commit before the first server sends headers.
+ release_response.notify_one();
+ }
+ let title = cdp_runtime_evaluate_string(&mut socket, &session_id, 10, "document.title").await;
+ pause_in_timer(&mut socket, &session_id, 11, "debugger;").await;
+ send_cdp_command(
+ &mut socket,
+ 12,
+ "Debugger.resume",
+ Some(&session_id),
+ json!({}),
+ )
+ .await;
+ let _ = socket.close(None).await;
+ abort_test_cdp_server(protocol_server).await;
+ fixture.abort();
+ assert!(
+ navigated.is_ok(),
+ "HTTP response preparation must exit the old pause"
+ );
+ assert_eq!(
+ title,
+ if supersede {
+ "second replacement"
+ } else {
+ "HTTP replacement"
+ }
+ );
+}
+
+#[tokio::test]
+async fn navigation_cancellation_at_request_stage_preserves_the_paused_document_and_debugger() {
+ assert_intercepted_navigation_while_paused("Request", InterceptionAction::Cancel).await;
+}
+
+#[tokio::test]
+async fn navigation_cancellation_at_response_stage_preserves_the_paused_document_and_debugger() {
+ assert_intercepted_navigation_while_paused("Response", InterceptionAction::Cancel).await;
+}
+
+#[tokio::test]
+async fn navigation_continues_an_intercepted_response_while_debugger_is_paused() {
+ assert_intercepted_navigation_while_paused("Response", InterceptionAction::Continue).await;
+}
+
+#[tokio::test]
+async fn navigation_fulfills_an_intercepted_response_while_debugger_is_paused() {
+ assert_intercepted_navigation_while_paused("Response", InterceptionAction::Fulfill).await;
+}
+
+#[derive(Clone, Copy)]
+enum InterceptionAction {
+ Cancel,
+ Continue,
+ Fulfill,
+}
+
+async fn assert_intercepted_navigation_while_paused(
+ request_stage: &str,
+ action: InterceptionAction,
+) {
+ let (fixture_addr, fixture) = spawn_dedicated_fixture_server(
+ Router::new().route(
+ "/",
+ get(|| async { axum::response::Html("<title>HTTP replacement</title>") }),
+ ),
+ "paused-navigation-cancellation",
+ );
+ let (cdp_addr, protocol_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,<title>old</title>")
+ .await;
+ send_cdp_command(
+ &mut socket,
+ 6,
+ "Debugger.enable",
+ Some(&session_id),
+ json!({}),
+ )
+ .await;
+ send_cdp_command(
+ &mut socket,
+ 7,
+ "Fetch.enable",
+ Some(&session_id),
+ json!({"patterns": [{
+ "urlPattern": "*", "resourceType": "Document", "requestStage": request_stage
+ }]}),
+ )
+ .await;
+ pause_in_timer(
+ &mut socket,
+ &session_id,
+ 8,
+ "debugger; globalThis.resumedNormally = 'yes';",
+ )
+ .await;
+ send_cdp_command_without_wait(
+ &mut socket,
+ 9,
+ "Page.navigate",
+ Some(&session_id),
+ json!({"url": format!("http://{fixture_addr}/")}),
+ )
+ .await;
+ let intercepted = recv_until_match(&mut socket, |message| {
+ message["method"] == "Fetch.requestPaused"
+ })
+ .await;
+ let request_id = intercepted
+ .iter()
+ .find(|message| message["method"] == "Fetch.requestPaused")
+ .unwrap()["params"]["requestId"]
+ .clone();
+ let (method, params) = match action {
+ InterceptionAction::Cancel => (
+ "Fetch.failRequest",
+ json!({"requestId": request_id, "errorReason": "Aborted"}),
+ ),
+ InterceptionAction::Continue => {
+ ("Fetch.continueResponse", json!({"requestId": request_id}))
+ }
+ InterceptionAction::Fulfill => (
+ "Fetch.fulfillRequest",
+ json!({
+ "requestId": request_id,
+ "responseCode": 200,
+ "responseHeaders": [{"name": "Content-Type", "value": "text/html"}],
+ "body": "PHRpdGxlPmZ1bGZpbGxlZDwvdGl0bGU+"
+ }),
+ ),
+ };
+ let mut completed = send_cdp_command(&mut socket, 10, method, Some(&session_id), params).await;
+ if !completed.iter().any(|message| message["id"] == 9) {
+ completed.extend(recv_until_id(&mut socket, 9).await);
+ }
+ assert!(
+ completed
+ .iter()
+ .any(|message| message["id"] == 10 && message.get("error").is_none())
+ );
+ match action {
+ InterceptionAction::Cancel => {
+ assert!(
+ !completed
+ .iter()
+ .any(|message| message["method"] == "Page.frameNavigated")
+ );
+ let resumed = send_cdp_command(
+ &mut socket,
+ 11,
+ "Debugger.resume",
+ Some(&session_id),
+ json!({}),
+ )
+ .await;
+ assert!(
+ resumed
+ .iter()
+ .any(|message| message["id"] == 11 && message.get("error").is_none()),
+ "cancellation must keep the current document paused: completed={completed:#?}, resumed={resumed:#?}"
+ );
+ }
+ InterceptionAction::Continue | InterceptionAction::Fulfill => {
+ assert!(
+ completed
+ .iter()
+ .any(|message| message["id"] == 9 && message.get("error").is_none())
+ );
+ if !completed
+ .iter()
+ .any(|message| message["method"] == "Page.loadEventFired")
+ {
+ recv_until_match(&mut socket, |message| {
+ message["method"] == "Page.loadEventFired"
+ })
+ .await;
+ }
+ }
+ }
+ let expected_title = match action {
+ InterceptionAction::Cancel => "old:yes",
+ InterceptionAction::Continue => "HTTP replacement:undefined",
+ InterceptionAction::Fulfill => "fulfilled:undefined",
+ };
+ assert_eq!(
+ cdp_runtime_evaluate_string(
+ &mut socket,
+ &session_id,
+ 12,
+ "document.title + ':' + globalThis.resumedNormally"
+ )
+ .await,
+ expected_title,
+ );
+ pause_in_timer(&mut socket, &session_id, 13, "debugger;").await;
+ send_cdp_command(
+ &mut socket,
+ 14,
+ "Debugger.resume",
+ Some(&session_id),
+ json!({}),
+ )
+ .await;
+ let _ = socket.close(None).await;
+ abort_test_cdp_server(protocol_server).await;
+ drop(fixture);
+}
diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rs
index b4f17a66f..8fedb47d1 100644
--- a/moli-protocol/src/conn.rs
+++ b/moli-protocol/src/conn.rs
@@ -537,8 +537,8 @@ pub(crate) use runtime_load::decode_data_url_response;
pub(crate) use runtime_load::{
BackgroundNavigationBodyCompletionSink, BackgroundNavigationEarlyResult,
BackgroundNavigationLoadJob, CompletedInitialDocumentPageBuild, FailedInitialDocumentPageBuild,
- InitialDocumentPageInstallResult, InitialDocumentPageOwner, PausedResponsePreparedDocument,
- PendingInitialDocumentPageBuild, ResponseCommitReady,
+ InitialDocumentPageInstallResult, InitialDocumentPageOwner, PendingInitialDocumentPageBuild,
+ ResponseCommitReady,
};
use scheduler_hooks::CdpSchedulerHooks;
use scheduler_state::CdpConnectionSchedulerState;
diff --git a/moli-protocol/src/conn/browser_context/target_session_owner.rs b/moli-protocol/src/conn/browser_context/target_session_owner.rs
index 1961e6a70..5a3444f81 100644
--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs
+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs
@@ -181,9 +181,16 @@ pub(crate) struct TargetNavigationLoadInputs {
pub(crate) permission_overrides: Vec<moli_core::page::PermissionOverrideRegistration>,
main_document_commit_seed: Option<RendererMainDocumentCommitSeed>,
session_history_position: Option<moli_session_history::SessionHistoryPosition>,
+ renderer_navigation: Option<(moli_core::page::RendererDevToolsTargetHandle, u64)>,
}
impl TargetNavigationLoadInputs {
+ pub(crate) fn prepare_to_replace_document(&self) {
+ if let Some((target, request_id)) = &self.renderer_navigation {
+ target.navigation_response_ready(*request_id);
+ }
+ }
+
pub(crate) fn with_main_document_commit_seed(
mut self,
seed: RendererMainDocumentCommitSeed,
@@ -346,6 +353,7 @@ impl TargetNavigationLoadInputs {
.navigation_history_state
.position_after_navigation(),
),
+ renderer_navigation: target.runtime_slot().page_slot().renderer_navigation(),
}
}
@@ -412,6 +420,7 @@ impl TargetNavigationLoadInputs {
permission_overrides: Vec::new(),
main_document_commit_seed: None,
session_history_position: None,
+ renderer_navigation: None,
}
}
diff --git a/moli-protocol/src/conn/fetch_support.rs b/moli-protocol/src/conn/fetch_support.rs
index 9bc66e029..9065ce5fa 100644
--- a/moli-protocol/src/conn/fetch_support.rs
+++ b/moli-protocol/src/conn/fetch_support.rs
@@ -7,7 +7,7 @@ use url::Url;
use super::body_spool::ensure_materialize_limit;
use super::{
CapturedBody, CapturedBodyWriter, CdpConnection, CommandOwnerScope, DocumentNavigationToken,
- NavigationDispatchState, NavigationLoadOutcome, PausedResponsePreparedDocument,
+ NavigationDispatchState, NavigationLoadOutcome,
};
use crate::devtools_runtime::{DevToolsNetworkInterceptId, DevToolsNetworkResourceType};
use crate::domains::network::MainDocumentBodyProgressSource;
@@ -790,7 +790,6 @@ pub(crate) struct PendingStreamingDocumentResponseNavigation {
pub(crate) response: StreamingRawResponse,
pub(crate) network_observation_journal: NetworkObservationJournal,
pub(crate) body_progress_source: MainDocumentBodyProgressSource,
- pub(crate) prepared_document: Option<Box<PausedResponsePreparedDocument>>,
}
impl PausedDocumentTransfer {
@@ -818,23 +817,6 @@ impl PausedDocumentTransfer {
matches!(self.state, PausedDocumentTransferState::Pending { .. })
}
- #[cfg(test)]
- pub(crate) fn prepared_renderer_agent_token(
- &self,
- ) -> Option<moli_core::page::RendererDevToolsAgentToken> {
- match &self.state {
- PausedDocumentTransferState::Pending {
- body:
- DocumentBodySource::StreamingRaw {
- prepared_document: Some(prepared_document),
- ..
- },
- ..
- } => Some(prepared_document.renderer_devtools_agent_token()),
- _ => None,
- }
- }
-
fn owner_session_id(&self) -> Option<&str> {
match &self.state {
PausedDocumentTransferState::Pending { navigation, .. }
@@ -879,7 +861,6 @@ impl PausedDocumentTransfer {
response,
network_observation_journal,
body_progress_source,
- prepared_document: _,
} => Ok(PendingFetchResponseOpenedBodyStream {
handle: handle.clone(),
buffered_bytes: None,
@@ -1010,7 +991,6 @@ impl PausedDocumentTransfer {
response,
network_observation_journal,
body_progress_source,
- prepared_document,
},
} => {
let Some(document_navigation_token) = document_navigation_token else {
@@ -1026,7 +1006,6 @@ impl PausedDocumentTransfer {
response,
network_observation_journal,
body_progress_source,
- prepared_document,
},
},
}));
@@ -1037,7 +1016,6 @@ impl PausedDocumentTransfer {
response,
network_observation_journal,
body_progress_source,
- prepared_document,
})
}
state => Err(Box::new(Self {
@@ -1383,7 +1361,6 @@ pub enum DocumentBodySource {
response: StreamingRawResponse,
network_observation_journal: NetworkObservationJournal,
body_progress_source: MainDocumentBodyProgressSource,
- prepared_document: Option<Box<PausedResponsePreparedDocument>>,
},
CapturedRaw {
requested_url: Url,
@@ -1564,12 +1541,8 @@ impl DocumentBodySource {
response,
network_observation_journal,
body_progress_source,
- prepared_document,
..
} => {
- if !has_response_override && let Some(prepared_document) = prepared_document {
- return Ok(prepared_document.resume_streaming(response, None));
- }
conn.build_navigation_from_streaming_raw_response_with_response_override_for_navigation_async(
navigation,
NetworkFetchResult::with_observation_journal(
@@ -1666,7 +1639,6 @@ impl DocumentBodySource {
response,
network_observation_journal,
body_progress_source,
- prepared_document: _,
} => {
let preserved_head = response.head();
let (head, body) = match capture_streaming_raw_response(response).await {
diff --git a/moli-protocol/src/conn/runtime_load.rs b/moli-protocol/src/conn/runtime_load.rs
index 9bba2b073..a20b57f07 100644
--- a/moli-protocol/src/conn/runtime_load.rs
+++ b/moli-protocol/src/conn/runtime_load.rs
@@ -495,95 +495,6 @@ impl Drop for ResponseCommitReady {
}
}
-pub struct PausedResponsePreparedDocument {
- prepared_page: PreparedDocumentPage,
- renderer_body_tx: mpsc::Sender<Vec<u8>>,
- renderer_completion_tx: oneshot::Sender<anyhow::Result<()>>,
- body_progress_source: MainDocumentBodyProgressSource,
- body_network_progress_state: MainDocumentBodyNetworkProgress,
- requested_url: Url,
- final_url: Url,
- request_method: String,
- request_headers: moli_fetch::RequestHeaders,
- response_status: u16,
- response_headers: Vec<(String, Vec<u8>)>,
- response_from_cache: bool,
- negotiated_http_version: Option<moli_fetch::NegotiatedHttpVersion>,
- network_observation_journal: NetworkObservationJournal,
- timing_started: Option<std::time::Instant>,
- main_document_commit: Option<Arc<RendererMainDocumentCommit>>,
-}
-
-impl std::fmt::Debug for PausedResponsePreparedDocument {
- fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- formatter
- .debug_struct("PausedResponsePreparedDocument")
- .field("requested_url", &self.requested_url)
- .field("final_url", &self.final_url)
- .field(
- "renderer_devtools_agent_token",
- &self.prepared_page.renderer_devtools_agent_token(),
- )
- .finish_non_exhaustive()
- }
-}
-
-impl PausedResponsePreparedDocument {
- #[cfg(test)]
- pub(crate) fn renderer_devtools_agent_token(
- &self,
- ) -> moli_core::page::RendererDevToolsAgentToken {
- self.prepared_page.renderer_devtools_agent_token()
- }
-
- pub(crate) fn resume_streaming(
- self,
- response: StreamingRawResponse,
- body_completion_sink: Option<BackgroundNavigationBodyCompletionSink>,
- ) -> NavigationLoadOutcome {
- let network_extra_info_available = !self.network_observation_journal.is_empty();
- self.body_progress_source.emit_response_metadata(
- &self.request_method,
- &self.request_headers.to_byte_strings(),
- response.request_cookie_report.as_ref(),
- &response.redirect_chain,
- &self.final_url,
- self.response_status,
- &self.response_headers,
- &response.cookie_set_reports,
- &self.network_observation_journal,
- network_extra_info_available,
- self.response_from_cache,
- self.negotiated_http_version,
- );
- let body_capture_task = spawn_streaming_body_capture(
- response,
- None,
- self.renderer_body_tx,
- self.renderer_completion_tx,
- );
- let ready = ResponseCommitReady {
- prepared_page: Some(self.prepared_page),
- body_capture: Some(ResponseCommitBodyCapture::Pending(body_capture_task)),
- body_completion_sink,
- body_progress_source: self.body_progress_source,
- body_network_progress_state: Some(self.body_network_progress_state),
- synthetic_body: false,
- requested_url: self.requested_url,
- final_url: self.final_url,
- request_method: self.request_method,
- request_headers: self.request_headers,
- response_status: self.response_status,
- response_headers: self.response_headers,
- response_from_cache: self.response_from_cache,
- timing_started: self.timing_started,
- main_document_commit: self.main_document_commit,
- network_error_page: None,
- };
- NavigationLoadOutcome::response_commit_ready(ready)
- }
-}
-
async fn first_nonempty_response_body_chunk(
response: &mut StreamingRawResponse,
) -> anyhow::Result<Option<Vec<u8>>> {
@@ -1387,6 +1298,7 @@ async fn build_navigation_from_streaming_raw_response_with_engine_async(
None
};
+ load_inputs.prepare_to_replace_document();
if response_headers_indicate_xml_document(&response_headers) {
let redirected = response.redirected;
let mut body_writer = CapturedBodyWriter::default();
@@ -1646,145 +1558,6 @@ impl CdpConnection {
.flatten()
}
- pub(crate) async fn prepare_paused_streaming_response_navigation_async(
- &mut self,
- navigation: &NavigationDispatchState,
- response: &StreamingRawResponse,
- network_observation_journal: &NetworkObservationJournal,
- body_progress_source: MainDocumentBodyProgressSource,
- ) -> anyhow::Result<Option<PausedResponsePreparedDocument>> {
- if super::downloads::response_headers_indicate_download(&response.headers)
- || response_headers_indicate_xml_document(&response.headers)
- || response_status_may_use_http_error_page(response.status)
- {
- return Ok(None);
- }
- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);
- if load_inputs.browser_context_id.is_none() {
- return Ok(None);
- }
- let requested_url = navigation.requested_url.clone();
- let network_extra_info_available = !network_observation_journal.is_empty();
- let request_method = navigation.request_method.clone();
- let request_headers = navigation.request_headers.clone();
- let timing_started = moli_trace::cdp_nav_timing_enabled().then(std::time::Instant::now);
- let final_url = response.final_url.clone();
- let response_status = response.status;
- let response_headers = response.headers.clone();
- let response_cookie_reports = response.cookie_set_reports.clone();
- let response_from_cache = response.from_cache;
- let negotiated_http_version = response.negotiated_http_version;
- let initial_request_cookie_report = response.request_cookie_report.clone();
- let redirect_chain = response
- .redirect_chain
- .clone()
- .into_iter()
- .map(Into::into)
- .collect::<Vec<_>>();
- let network_events = CompletedMainDocumentNetworkEvents::new(
- request_method.clone(),
- request_headers.to_byte_strings(),
- initial_request_cookie_report,
- response_status,
- response_headers.clone(),
- response_cookie_reports.clone(),
- redirect_chain.clone(),
- network_extra_info_available,
- response_from_cache,
- )
- .with_negotiated_http_version(negotiated_http_version)
- .with_network_observation_journal(network_observation_journal.clone());
- let body_network_progress_state =
- body_progress_source.body_network_progress_for_completed_events(network_events);
- let (renderer_body_tx, renderer_body_rx) =
- mpsc::channel(EXTERNAL_RAW_BODY_CHANNEL_CAPACITY);
- let (renderer_completion_tx, renderer_completion_rx) = oneshot::channel();
- let raw_body = moli_core::runtime::ExternalRawDocumentBodyStream::new(
- renderer_body_rx,
- renderer_completion_rx,
- );
- let shared_resource_runtime =
- self.shared_resource_runtime_for_navigation_load_inputs(&load_inputs);
- let mut engine = self.navigation_engine_handle_for_load_inputs(&load_inputs);
- if let Some(resource_runtime) = shared_resource_runtime {
- engine
- .adopt_registered_resource_runtime(resource_runtime)
- .context("failed to update navigation runtime policy")?;
- }
- let (fetch_subresource_interception_enabled, fetch_subresource_interception_resource_type) =
- load_inputs.fetch_subresource_interception;
- let page_storage = load_inputs.page_storage_handles();
- let main_document_commit = load_inputs
- .main_document_commit_for_final_url(&final_url, None)
- .map(Arc::new);
- let page_reservation =
- self.reserve_renderer_page_for_owner(&navigation.owner, &load_inputs, &engine);
- let prepared_page = engine
- .prepare_streaming_raw_page_from_external_body_with_storage_and_inspector_session_restores_async(
- page_reservation,
- page_storage.into_navigation_storage(),
- requested_url.clone(),
- final_url.clone(),
- load_inputs.navigation_initiator_url.clone(),
- response.redirected,
- redirect_chain.len(),
- response_status,
- response_headers.clone(),
- raw_body,
- load_inputs.document_start_scripts.clone(),
- load_inputs.runtime_bindings.clone(),
- load_inputs
- .runtime_inspector_session_restore_snapshots
- .clone(),
- load_inputs.extra_http_headers.clone(),
- load_inputs.script_execution_disabled,
- load_inputs.bypass_content_security_policy,
- load_inputs.emulated_media.clone(),
- load_inputs.viewport_surface,
- load_inputs.network_offline,
- load_inputs.blocked_url_patterns.clone(),
- fetch_subresource_interception_enabled,
- fetch_subresource_interception_resource_type,
- PageVmInitStage::DomContentLoaded,
- RendererReplyBoundary::DocumentCommit,
- load_inputs.root_frame_id.clone(),
- CommittedDocumentResourceSource::Synthetic,
- None,
- main_document_commit.as_deref().cloned(),
- )
- .await
- .with_context(|| format!(
- "failed to prepare response-stage page `{}`",
- requested_url
- ))?;
- if let Some(started) = timing_started {
- tracing::info!(
- target: "moli_cdp_nav_timing",
- url = %requested_url,
- stage = "response_stage_document_prepared",
- elapsed_ms = started.elapsed().as_millis(),
- );
- }
- Ok(Some(PausedResponsePreparedDocument {
- prepared_page,
- renderer_body_tx,
- renderer_completion_tx,
- body_progress_source,
- body_network_progress_state,
- requested_url,
- final_url,
- request_method,
- request_headers,
- response_status,
- response_headers,
- response_from_cache,
- negotiated_http_version,
- network_observation_journal: network_observation_journal.clone(),
- timing_started,
- main_document_commit,
- }))
- }
-
pub(crate) fn start_initial_document_page_ensure_for_owner(
&mut self,
owner: &CommandOwnerScope,
@@ -3825,6 +3598,7 @@ async fn prepare_captured_document_response_with_engine_async(
synthetic_body: bool,
reply_boundary: RendererReplyBoundary,
) -> anyhow::Result<ResponseCommitReady> {
+ load_inputs.prepare_to_replace_document();
let network_extra_info_available = !network_observation_journal.is_empty();
body_progress_source.emit_response_metadata(
&request_method,
diff --git a/moli-protocol/src/conn/state/attachment_identity.rs b/moli-protocol/src/conn/state/attachment_identity.rs
index 163b7770f..f1fd8bae8 100644
--- a/moli-protocol/src/conn/state/attachment_identity.rs
+++ b/moli-protocol/src/conn/state/attachment_identity.rs
@@ -36,6 +36,10 @@ impl TargetPageAttachmentId {
pub(crate) struct NavigationRequestId(NonZeroU64);
impl NavigationRequestId {
+ pub(crate) fn get(self) -> u64 {
+ self.0.get()
+ }
+
pub(crate) fn allocate() -> Self {
Self(allocate_nonzero_u64(
&NEXT_NAVIGATION_REQUEST_ID,
diff --git a/moli-protocol/src/conn/state/fetch.rs b/moli-protocol/src/conn/state/fetch.rs
index 9c086f7e9..12213759b 100644
--- a/moli-protocol/src/conn/state/fetch.rs
+++ b/moli-protocol/src/conn/state/fetch.rs
@@ -2165,17 +2165,6 @@ impl TargetFetchOwner {
.is_some_and(PausedDocumentTransfer::is_pending)
}
- #[cfg(test)]
- pub(crate) fn pending_fetch_response_prepared_renderer_agent_for_test(
- &self,
- request_id: &str,
- ) -> Option<moli_core::page::RendererDevToolsAgentToken> {
- self.pending
- .pending_fetch_response_transfers
- .get(request_id)
- .and_then(PausedDocumentTransfer::prepared_renderer_agent_token)
- }
-
#[cfg(test)]
pub(crate) fn active_fetch_response_body_stream_request_id_for_test(
&self,
diff --git a/moli-protocol/src/conn/state/page_slot.rs b/moli-protocol/src/conn/state/page_slot.rs
index 3ee27ba80..c9e3765a2 100644
--- a/moli-protocol/src/conn/state/page_slot.rs
+++ b/moli-protocol/src/conn/state/page_slot.rs
@@ -84,16 +84,24 @@ pub(crate) struct PendingNavigationRequest {
cancellation_handles: Vec<moli_fetch::FetchCancelHandle>,
background_completion_pending: bool,
committed: bool,
+ renderer_target: Option<moli_core::page::RendererDevToolsTargetHandle>,
}
impl PendingNavigationRequest {
- fn new(token: DocumentNavigationToken) -> Self {
+ fn new(
+ token: DocumentNavigationToken,
+ renderer_target: Option<moli_core::page::RendererDevToolsTargetHandle>,
+ ) -> Self {
+ if let Some(target) = &renderer_target {
+ target.navigation_started(token.request_id.get());
+ }
Self {
token,
page_attachment_id: TargetPageAttachmentId::allocate(),
cancellation_handles: vec![moli_fetch::FetchCancelHandle::new()],
background_completion_pending: false,
committed: false,
+ renderer_target,
}
}
@@ -127,8 +135,15 @@ impl PendingNavigationRequest {
self.cancellation_handles.clear();
}
- fn cancel(&self) {
- for cancellation in &self.cancellation_handles {
+ fn finish_renderer_navigation(&mut self) {
+ if let Some(target) = self.renderer_target.take() {
+ target.navigation_finished(self.token.request_id.get());
+ }
+ }
+
+ fn cancel(&mut self) {
+ self.finish_renderer_navigation();
+ for cancellation in self.cancellation_handles.drain(..) {
cancellation.cancel();
}
}
@@ -667,10 +682,31 @@ impl TargetPageSlot {
request_id: NavigationRequestId::allocate(),
};
self.pending_renderer_page = None;
- self.pending_navigation_request = Some(PendingNavigationRequest::new(token.clone()));
+ self.cancel_pending_document_navigation();
+ let renderer_target = self.loaded_page().map(Page::renderer_devtools_target);
+ self.pending_navigation_request = Some(PendingNavigationRequest::new(
+ token.clone(),
+ renderer_target,
+ ));
token
}
+ pub(crate) fn renderer_navigation(
+ &self,
+ ) -> Option<(moli_core::page::RendererDevToolsTargetHandle, u64)> {
+ let request = self.pending_navigation_request.as_ref()?;
+ Some((
+ request.renderer_target.clone()?,
+ request.token.request_id.get(),
+ ))
+ }
+
+ fn cancel_pending_document_navigation(&mut self) {
+ if let Some(mut request) = self.pending_navigation_request.take() {
+ request.cancel();
+ }
+ }
+
pub(crate) fn document_navigation_cancellation_handle(
&self,
token: &DocumentNavigationToken,
@@ -828,6 +864,7 @@ impl TargetPageSlot {
};
self.committed_document_navigation = Some(token.clone());
request.committed = true;
+ request.finish_renderer_navigation();
if !request.background_completion_pending {
request.retire_without_cancellation();
self.pending_navigation_request = None;
@@ -853,7 +890,7 @@ impl TargetPageSlot {
) {
self.pending_renderer_page = None;
}
- self.pending_navigation_request = None;
+ self.cancel_pending_document_navigation();
return true;
}
false
@@ -863,7 +900,7 @@ impl TargetPageSlot {
self.finish_renderer_document_lifecycle_observers(
RendererDocumentLifecycleObservation::Unavailable,
);
- self.pending_navigation_request = None;
+ self.cancel_pending_document_navigation();
self.committed_document_navigation = None;
self.pending_renderer_page = None;
self.renderer_document_lifecycle = RendererDocumentLifecycleProtocolState::default();
diff --git a/moli-protocol/src/conn/tests/navigation_error.rs b/moli-protocol/src/conn/tests/navigation_error.rs
index 574565782..7e85b99f1 100644
--- a/moli-protocol/src/conn/tests/navigation_error.rs
+++ b/moli-protocol/src/conn/tests/navigation_error.rs
@@ -40,7 +40,6 @@ fn failing_streamed_document(
response,
network_observation_journal: Default::default(),
body_progress_source: Default::default(),
- prepared_document: None,
}
}
diff --git a/moli-protocol/src/domains/fetch/commands.rs b/moli-protocol/src/domains/fetch/commands.rs
index 64118705a..1c5887273 100644
--- a/moli-protocol/src/domains/fetch/commands.rs
+++ b/moli-protocol/src/domains/fetch/commands.rs
@@ -1872,30 +1872,8 @@ fn continue_streaming_document_response_in_background(
response,
network_observation_journal,
body_progress_source,
- prepared_document,
} = pending;
let cancellation = response.cancellation_handle();
- if response_code.is_none()
- && response_headers.is_empty()
- && let Some(prepared_document) = prepared_document
- {
- conn.arm_background_navigation_completion(&document_navigation_token, Some(cancellation));
- tokio::task::spawn_local(async move {
- let body_completion_sink = BackgroundNavigationBodyCompletionSink::new(
- sender.clone(),
- document_navigation_token.clone(),
- navigation.clone(),
- );
- let navigation_result =
- prepared_document.resume_streaming(response, Some(body_completion_sink));
- let _ = sender.send(page::BackgroundNavigationCompletion::new(
- document_navigation_token,
- navigation,
- Ok(navigation_result),
- ));
- });
- return;
- }
let job = conn.background_streaming_response_navigation_load_job_for_navigation(
&navigation,
response,
diff --git a/moli-protocol/src/domains/fetch/navigation.rs b/moli-protocol/src/domains/fetch/navigation.rs
index 687a913a8..9127d0740 100644
--- a/moli-protocol/src/domains/fetch/navigation.rs
+++ b/moli-protocol/src/domains/fetch/navigation.rs
@@ -530,27 +530,9 @@ async fn handle_streaming_response_head_for_navigation_into_buffer_async(
network_extra_info_available,
);
out.extend_background_events_after_messages(response_extra_info_events);
- let prepared_document = match conn
- .prepare_paused_streaming_response_navigation_async(
- &pending.navigation,
- response.response(),
- network_observation_journal,
- body_progress_source.clone(),
- )
- .await
- {
- Ok(prepared_document) => prepared_document,
- Err(error) => {
- complete_pending_fetch_navigation_result_into_buffer_async(
- conn,
- out,
- pending,
- Err(error),
- )
- .await;
- return;
- }
- };
+ // Keep only the response until the client accepts it. Preparing a renderer
+ // here would wait on the old document's debugger pause before we could even
+ // publish Fetch.requestPaused. Continue/fulfill owns document replacement.
let (response, network_observation_journal) = response.into_parts_with_observation_journal();
conn.register_pending_fetch_response_navigation_for_owner(
&pending.navigation.owner,
@@ -564,7 +546,6 @@ async fn handle_streaming_response_head_for_navigation_into_buffer_async(
response,
network_observation_journal,
body_progress_source,
- prepared_document: prepared_document.map(Box::new),
},
);
out.extend_background_events_after_messages([navigation_response_stage_request_paused_event(
diff --git a/moli-protocol/src/domains/fetch/tests/navigation_response_stage.rs b/moli-protocol/src/domains/fetch/tests/navigation_response_stage.rs
index 8c986f6b5..a45cf0a97 100644
--- a/moli-protocol/src/domains/fetch/tests/navigation_response_stage.rs
+++ b/moli-protocol/src/domains/fetch/tests/navigation_response_stage.rs
@@ -72,16 +72,15 @@ async fn response_stage_pause_happens_before_navigation_body_eof() {
.as_str()
.expect("response-stage request id")
.to_owned();
- let prepared_agent = ctx
- .conn
- .browser_context
- .as_ref()
- .and_then(|bc| {
- bc.active_page_target()
- .fetch_owner
- .pending_fetch_response_prepared_renderer_agent_for_test(&response_request_id)
- })
- .expect("final response head should reserve a renderer agent before continueResponse");
+ assert!(
+ ctx.conn
+ .browser_context
+ .as_ref()
+ .unwrap()
+ .active_page_target()
+ .fetch_owner
+ .pending_fetch_response_transfer_is_pending_for_test(&response_request_id)
+ );
assert!(
ctx.conn
.browser_context
@@ -106,19 +105,6 @@ async fn response_stage_pause_happens_before_navigation_body_eof() {
Some("SID-1"),
);
- {
- let page = ctx
- .conn
- .browser_context
- .as_ref()
- .and_then(|bc| bc.loaded_page())
- .expect("loaded page");
- assert_eq!(
- page.renderer_devtools_agent_token(),
- prepared_agent,
- "continueResponse must commit the exact agent reserved at the response head"
- );
- }
assert!(
loaded_page_html_for_test(&mut ctx)
.await
@@ -165,11 +151,7 @@ async fn assert_empty_http_error_response_stage(ctx: &mut TestContext, url: &str
ctx.conn
.browser_context
.as_ref()
- .and_then(|bc| {
- bc.active_page_target()
- .fetch_owner
- .pending_fetch_response_prepared_renderer_agent_for_test(&request_id)
- })
+ .and_then(|bc| bc.loaded_page())
.is_none(),
"an empty HTTP error must be classified from its body after continueResponse"
);
@@ -857,7 +839,7 @@ async fn fulfill_request_commit_uses_configuration_added_while_paused_before_aut
}
#[tokio::test(flavor = "multi_thread")]
-async fn interleaved_response_heads_only_commit_the_current_prepared_document() {
+async fn interleaved_response_heads_only_commit_the_current_response() {
async fn first() -> impl IntoResponse {
(
[(CONTENT_TYPE.as_str(), "text/html")],
@@ -919,16 +901,15 @@ async fn interleaved_response_heads_only_commit_the_current_prepared_document()
.as_str()
.expect("first response-stage request id")
.to_owned();
- let first_agent = ctx
- .conn
- .browser_context
- .as_ref()
- .and_then(|bc| {
- bc.active_page_target()
- .fetch_owner
- .pending_fetch_response_prepared_renderer_agent_for_test(&first_request_id)
- })
- .expect("first response head should reserve a renderer agent");
+ assert!(
+ ctx.conn
+ .browser_context
+ .as_ref()
+ .unwrap()
+ .active_page_target()
+ .fetch_owner
+ .pending_fetch_response_transfer_is_pending_for_test(&first_request_id)
+ );
ctx.process_async(json!({
"id": 366,
@@ -942,17 +923,15 @@ async fn interleaved_response_heads_only_commit_the_current_prepared_document()
.as_str()
.expect("second response-stage request id")
.to_owned();
- let second_agent = ctx
- .conn
- .browser_context
- .as_ref()
- .and_then(|bc| {
- bc.active_page_target()
- .fetch_owner
- .pending_fetch_response_prepared_renderer_agent_for_test(&second_request_id)
- })
- .expect("second response head should reserve a renderer agent");
- assert_ne!(first_agent, second_agent);
+ assert!(
+ ctx.conn
+ .browser_context
+ .as_ref()
+ .unwrap()
+ .active_page_target()
+ .fetch_owner
+ .pending_fetch_response_transfer_is_pending_for_test(&second_request_id)
+ );
let attachment_before_continue = ctx.conn.browser_context.as_ref().and_then(|bc| {
bc.active_page_target()
@@ -1003,8 +982,6 @@ async fn interleaved_response_heads_only_commit_the_current_prepared_document()
.as_ref()
.and_then(|bc| bc.loaded_page())
.expect("current navigation should commit a page");
- assert_eq!(page.renderer_devtools_agent_token(), second_agent);
- assert_ne!(page.renderer_devtools_agent_token(), first_agent);
let html = page
.serialize_html_async()
.await
@@ -1802,16 +1779,12 @@ async fn fail_request_at_response_stage_aborts_navigation() {
.current_renderer_attachment()
});
assert!(
- ctx.conn
- .browser_context
- .as_ref()
- .and_then(|bc| {
- bc.active_page_target()
- .fetch_owner
- .pending_fetch_response_prepared_renderer_agent_for_test(&response_request_id)
- })
- .is_some(),
- "response head should own a prepared candidate before cancellation"
+ ctx.conn.browser_context.as_ref().is_some_and(|bc| {
+ bc.active_page_target()
+ .fetch_owner
+ .pending_fetch_response_transfer_is_pending_for_test(&response_request_id)
+ }),
+ "response head should retain its pending transfer before cancellation"
);
ctx.process_async(json!({
@@ -1834,14 +1807,14 @@ async fn fail_request_at_response_stage_aborts_navigation() {
.runtime_slot
.current_renderer_attachment(),
attachment_before_cancel,
- "canceling a response-stage candidate must not switch the renderer channel"
+ "canceling a response-stage transfer must not switch the renderer channel"
);
server.abort();
}
#[tokio::test(flavor = "multi_thread")]
-async fn fulfill_request_at_response_stage_replaces_the_network_candidate_once() {
+async fn fulfill_request_at_response_stage_replaces_the_network_response_once() {
async fn handler() -> impl IntoResponse {
(
[(CONTENT_TYPE.as_str(), "text/html")],
@@ -1891,16 +1864,15 @@ async fn fulfill_request_at_response_stage_replaces_the_network_candidate_once()
.as_str()
.expect("response-stage request id")
.to_owned();
- let network_agent = ctx
- .conn
- .browser_context
- .as_ref()
- .and_then(|bc| {
- bc.active_page_target()
- .fetch_owner
- .pending_fetch_response_prepared_renderer_agent_for_test(&request_id)
- })
- .expect("network response head should reserve a renderer agent");
+ assert!(
+ ctx.conn
+ .browser_context
+ .as_ref()
+ .unwrap()
+ .active_page_target()
+ .fetch_owner
+ .pending_fetch_response_transfer_is_pending_for_test(&request_id)
+ );
ctx.process_async(json!({
"id": 371,
@@ -1927,11 +1899,6 @@ async fn fulfill_request_at_response_stage_replaces_the_network_candidate_once()
.as_ref()
.and_then(|bc| bc.loaded_page())
.expect("synthetic response should commit a page");
- assert_ne!(
- page.renderer_devtools_agent_token(),
- network_agent,
- "fulfillRequest must discard the prepared network response candidate"
- );
let html = page
.serialize_html_async()
.await
diff --git a/moli-protocol/src/domains/network/main_document_progress/mod.rs b/moli-protocol/src/domains/network/main_document_progress/mod.rs
index 7764c9120..3502b9b72 100644
--- a/moli-protocol/src/domains/network/main_document_progress/mod.rs
+++ b/moli-protocol/src/domains/network/main_document_progress/mod.rs
@@ -71,6 +71,16 @@ pub(crate) enum FailedNavigationDocumentPolicy {
}
impl FailedNavigationDocumentPolicy {
+ fn for_navigation_error(error_text: &str) -> Self {
+ // Fetch.failRequest supplies the CDP reason "Aborted", while the
+ // transport supplies net::ERR_ABORTED. Both cancel the provisional
+ // load without discarding the currently committed document.
+ match error_text {
+ "Aborted" | moli_fetch::NET_ERR_ABORTED_ERROR_TEXT => Self::PreserveCommittedDocument,
+ _ => Self::InvalidateCommittedDocument,
+ }
+ }
+
pub(crate) fn invalidates_committed_document(self) -> bool {
matches!(self, Self::InvalidateCommittedDocument)
}
@@ -350,11 +360,12 @@ fn materialize_navigation_load_outcome(
materialize_download_navigation_progress(conn, state, *navigation),
),
NavigationLoadOutcome::NetworkFailure(error_text) => {
+ let document_policy = FailedNavigationDocumentPolicy::for_navigation_error(&error_text);
MaterializedNavigationLoadOutcome::Failed(materialize_failed_navigation_progress(
conn,
state,
error_text,
- FailedNavigationDocumentPolicy::InvalidateCommittedDocument,
+ document_policy,
FailedNavigationResponseMode::CdpErrorTextResult,
))
}
@@ -378,11 +389,12 @@ pub(crate) fn materialize_navigation_load_result(
Some(blocked) => blocked.to_string(),
None => format!("{error:#}"),
};
+ let document_policy = FailedNavigationDocumentPolicy::for_navigation_error(&error_text);
MaterializedNavigationLoadOutcome::Failed(materialize_failed_navigation_progress(
conn,
state,
error_text,
- FailedNavigationDocumentPolicy::InvalidateCommittedDocument,
+ document_policy,
FailedNavigationResponseMode::ProtocolError,
))
}
diff --git a/moli-protocol/src/domains/network/main_document_progress/tests.rs b/moli-protocol/src/domains/network/main_document_progress/tests.rs
index d5e79a961..bd7b17dae 100644
--- a/moli-protocol/src/domains/network/main_document_progress/tests.rs
+++ b/moli-protocol/src/domains/network/main_document_progress/tests.rs
@@ -18,6 +18,26 @@ use super::gate::{
};
use super::*;
+#[test]
+fn aborted_navigation_preserves_the_document_without_hiding_other_failures() {
+ for error_text in ["Aborted", "net::ERR_ABORTED"] {
+ assert_eq!(
+ FailedNavigationDocumentPolicy::for_navigation_error(error_text),
+ FailedNavigationDocumentPolicy::PreserveCommittedDocument,
+ );
+ }
+ for error_text in [
+ "Failed",
+ "net::ERR_CONNECTION_RESET",
+ "net::ERR_BLOCKED_BY_CLIENT",
+ ] {
+ assert_eq!(
+ FailedNavigationDocumentPolicy::for_navigation_error(error_text),
+ FailedNavigationDocumentPolicy::InvalidateCommittedDocument,
+ );
+ }
+}
+
fn completed_events() -> CompletedMainDocumentNetworkEvents {
CompletedMainDocumentNetworkEvents::new(
"GET".to_owned(),
diff --git a/moli-renderer-v8/src/devtools/ingress/io.rs b/moli-renderer-v8/src/devtools/ingress/io.rs
index d19809300..80b93402b 100644
--- a/moli-renderer-v8/src/devtools/ingress/io.rs
+++ b/moli-renderer-v8/src/devtools/ingress/io.rs
@@ -529,7 +529,9 @@ impl RendererInspectorIoIngress {
&self,
pause_bridge: &crate::devtools::pause::RendererInspectorPauseBridge,
) -> Option<RendererInspectorIoCommand> {
- pause_bridge.wait_for_pause_work(|| self.claim_for_pause())
+ pause_bridge
+ .wait_for_pause_work(|| self.claim_for_pause())
+ .ok()
}
fn claim_next(
diff --git a/moli-renderer-v8/src/devtools/pause/loop_state.rs b/moli-renderer-v8/src/devtools/pause/loop_state.rs
index 686e8921f..ff13b5af8 100644
--- a/moli-renderer-v8/src/devtools/pause/loop_state.rs
+++ b/moli-renderer-v8/src/devtools/pause/loop_state.rs
@@ -17,3 +17,11 @@ pub(crate) enum RendererInspectorPauseLoopPolicy {
MainAndIo,
IoOnly,
}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum RendererInspectorPauseExitReason {
+ Resumed,
+ Navigation,
+ SessionDetached,
+ TargetClosed,
+}
diff --git a/moli-renderer-v8/src/devtools/pause/mod.rs b/moli-renderer-v8/src/devtools/pause/mod.rs
index 5f4075421..58d1fe754 100644
--- a/moli-renderer-v8/src/devtools/pause/mod.rs
+++ b/moli-renderer-v8/src/devtools/pause/mod.rs
@@ -24,6 +24,7 @@ use crate::runtime::{
mod causality;
mod loop_state;
+mod navigation;
use causality::{
RendererInspectorPauseCommandDispatch, RendererInspectorPauseCommandTransition,
@@ -32,8 +33,9 @@ use causality::{
pub(crate) use causality::{
RendererInspectorPauseCommandOutputRoute, RendererInspectorPauseNotificationRoute,
};
-pub(crate) use loop_state::RendererInspectorPauseLoopPolicy;
use loop_state::RendererInspectorPausePhase;
+pub(crate) use loop_state::{RendererInspectorPauseExitReason, RendererInspectorPauseLoopPolicy};
+use navigation::RendererProvisionalLoad;
#[derive(Clone)]
pub(crate) struct RendererInspectorPauseBridge {
@@ -56,6 +58,7 @@ struct RendererInspectorPauseBridgeState {
pause_loop_policy: RendererInspectorPauseLoopPolicy,
quit_requested: bool,
session_detach_arms: usize,
+ provisional_load: Option<RendererProvisionalLoad>,
target_closed: bool,
pending_prefaces: VecDeque<RendererInspectorPausePreface>,
paused_sessions_awaiting_resumed: HashSet<(RendererDevToolsAgentToken, DevToolsSessionKey)>,
@@ -125,6 +128,7 @@ impl RendererInspectorPauseBridge {
pause_loop_policy: RendererInspectorPauseLoopPolicy::MainAndIo,
quit_requested: false,
session_detach_arms: 0,
+ provisional_load: None,
target_closed: false,
pending_prefaces: VecDeque::new(),
paused_sessions_awaiting_resumed: HashSet::new(),
@@ -147,6 +151,7 @@ impl std::fmt::Debug for RendererInspectorPauseBridge {
.field("pause_loop_policy", &state.pause_loop_policy)
.field("quit_requested", &state.quit_requested)
.field("session_detach_arms", &state.session_detach_arms)
+ .field("provisional_load", &state.provisional_load)
.field("target_closed", &state.target_closed)
.field("pending_prefaces", &state.pending_prefaces.len())
.field(
@@ -359,14 +364,29 @@ impl RendererInspectorPauseBridge {
Some(state.pause_loop_policy)
}
- pub(crate) fn wait_for_pause_work<T>(&self, mut claim: impl FnMut() -> Option<T>) -> Option<T> {
+ pub(crate) fn wait_for_pause_work<T>(
+ &self,
+ mut claim: impl FnMut() -> Option<T>,
+ ) -> Result<T, RendererInspectorPauseExitReason> {
let mut state = self.shared.state.lock();
loop {
- if state.target_closed || state.quit_requested || state.session_detach_arms != 0 {
- return None;
+ if state.target_closed {
+ return Err(RendererInspectorPauseExitReason::TargetClosed);
+ }
+ if matches!(
+ state.provisional_load,
+ Some(RendererProvisionalLoad::ReplacingDocument(_))
+ ) {
+ return Err(RendererInspectorPauseExitReason::Navigation);
+ }
+ if state.session_detach_arms != 0 {
+ return Err(RendererInspectorPauseExitReason::SessionDetached);
+ }
+ if state.quit_requested {
+ return Err(RendererInspectorPauseExitReason::Resumed);
}
if let Some(work) = claim() {
- return Some(work);
+ return Ok(work);
}
self.shared.pause_loop_wake.wait(&mut state);
}
diff --git a/moli-renderer-v8/src/devtools/pause/navigation.rs b/moli-renderer-v8/src/devtools/pause/navigation.rs
new file mode 100644
index 000000000..07fcbc6aa
--- /dev/null
+++ b/moli-renderer-v8/src/devtools/pause/navigation.rs
@@ -0,0 +1,206 @@
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) enum RendererProvisionalLoad {
+ WaitingForResponse(u64),
+ ReplacingDocument(u64),
+}
+
+impl RendererProvisionalLoad {
+ fn request_id(self) -> u64 {
+ match self {
+ Self::WaitingForResponse(id) | Self::ReplacingDocument(id) => id,
+ }
+ }
+}
+
+impl crate::devtools::target::RendererDevToolsTargetHandle {
+ /// Records the current navigation without disturbing a paused document.
+ /// The caller owns one current request and supplies its unique identity.
+ pub fn navigation_started(&self, request_id: u64) {
+ let mut state = self.pause_ref().shared.state.lock();
+ if !state.target_closed
+ && state
+ .provisional_load
+ .is_none_or(|load| load.request_id() != request_id)
+ {
+ state.provisional_load = Some(RendererProvisionalLoad::WaitingForResponse(request_id));
+ }
+ }
+
+ /// Unblocks the old document only when this response will replace it.
+ /// A canceled or superseded load job cannot reactivate this policy.
+ pub fn navigation_response_ready(&self, request_id: u64) {
+ let pause = self.pause_ref();
+ let mut state = pause.shared.state.lock();
+ if !state.target_closed
+ && state.provisional_load
+ == Some(RendererProvisionalLoad::WaitingForResponse(request_id))
+ {
+ state.provisional_load = Some(RendererProvisionalLoad::ReplacingDocument(request_id));
+ pause.shared.pause_loop_wake.notify_all();
+ }
+ }
+
+ /// Ends the matching provisional load at commit or cancellation. Retained
+ /// target handles have no effect on this document's debugger policy.
+ pub fn navigation_finished(&self, request_id: u64) {
+ let mut state = self.pause_ref().shared.state.lock();
+ if state
+ .provisional_load
+ .is_some_and(|load| load.request_id() == request_id)
+ {
+ state.provisional_load = None;
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::super::{RendererInspectorPauseBridge, RendererInspectorPauseExitReason};
+ use crate::devtools::{
+ ingress::{io::RendererInspectorIoIngress, main::RendererInspectorMainIngress},
+ route::RendererInspectorSessionExecutorRouteId,
+ target::RendererDevToolsTargetHandle,
+ };
+
+ fn target() -> RendererDevToolsTargetHandle {
+ let pause = RendererInspectorPauseBridge::default();
+ let main = RendererInspectorMainIngress::new(
+ RendererInspectorSessionExecutorRouteId::new(1),
+ pause.pause_loop_wake(),
+ );
+ let io = RendererInspectorIoIngress::new(pause.pause_loop_wake(), None);
+ RendererDevToolsTargetHandle::new(pause, main, io)
+ }
+
+ fn assert_debugging_enabled(target: &RendererDevToolsTargetHandle) {
+ assert_eq!(target.pause_ref().wait_for_pause_work(|| Some(42)), Ok(42));
+ }
+
+ fn assert_navigation_exit(target: &RendererDevToolsTargetHandle) {
+ assert_eq!(
+ target.pause_ref().wait_for_pause_work(|| Some(42)),
+ Err(RendererInspectorPauseExitReason::Navigation)
+ );
+ }
+
+ #[test]
+ fn navigation_waits_for_response_and_duplicate_notifications_are_idempotent() {
+ let target = target();
+ assert_debugging_enabled(&target);
+ target.navigation_started(1);
+ assert_debugging_enabled(&target);
+ target.navigation_response_ready(1);
+ assert_navigation_exit(&target);
+ target.navigation_response_ready(1);
+ target.navigation_started(1);
+ assert_navigation_exit(&target);
+ target.navigation_finished(1);
+ target.navigation_finished(1);
+ assert_debugging_enabled(&target);
+ }
+
+ #[test]
+ fn canceled_load_job_cannot_reactivate_pauses_even_with_a_retained_handle() {
+ for response_ready in [false, true] {
+ let target = target();
+ let job = target.clone();
+ target.navigation_started(1);
+ if response_ready {
+ job.navigation_response_ready(1);
+ }
+ target.navigation_finished(1);
+ assert_debugging_enabled(&job);
+ job.navigation_response_ready(1);
+ assert_debugging_enabled(&target);
+ }
+ }
+
+ #[test]
+ fn superseded_response_and_completion_cannot_change_the_current_navigation() {
+ let target = target();
+ target.navigation_started(1);
+ target.navigation_response_ready(1);
+ target.navigation_started(2);
+ target.navigation_response_ready(1);
+ assert_debugging_enabled(&target);
+ target.navigation_response_ready(2);
+ target.navigation_finished(1);
+ assert_navigation_exit(&target);
+ target.navigation_finished(2);
+ assert_debugging_enabled(&target);
+ }
+
+ #[test]
+ fn navigation_policy_is_document_local_and_handle_drop_does_not_finish_it() {
+ let first = target();
+ let second = target();
+ first.navigation_started(1);
+ first.navigation_response_ready(1);
+ drop(first.clone());
+ assert_navigation_exit(&first);
+ assert_debugging_enabled(&second);
+ second.navigation_finished(1);
+ assert_navigation_exit(&first);
+ }
+
+ #[test]
+ fn pause_exit_reason_is_preserved_after_navigation_completion() {
+ let target = target();
+ target.navigation_started(1);
+ target.navigation_response_ready(1);
+ let reason = target.pause_ref().wait_for_pause_work(|| Some(42));
+ target.navigation_finished(1);
+ assert_eq!(reason, Err(RendererInspectorPauseExitReason::Navigation));
+ assert_debugging_enabled(&target);
+ }
+
+ #[test]
+ fn closing_target_takes_precedence_and_late_notifications_cannot_reopen_it() {
+ let target = target();
+ target.navigation_started(1);
+ target.navigation_response_ready(1);
+ target.pause_ref().close_target();
+ target.navigation_finished(1);
+ target.navigation_started(2);
+ target.navigation_response_ready(2);
+ assert_eq!(
+ target.pause_ref().wait_for_pause_work(|| Some(42)),
+ Err(RendererInspectorPauseExitReason::TargetClosed)
+ );
+ }
+
+ #[test]
+ fn response_ready_wakes_the_pause_loop_and_covers_later_pauses() {
+ let target = target();
+ target.navigation_started(1);
+ let pause = target.pause();
+ let (waiting_tx, waiting_rx) = std::sync::mpsc::channel();
+ let (exited_tx, exited_rx) = std::sync::mpsc::channel();
+ let waiter = std::thread::spawn(move || {
+ let mut waiting_tx = Some(waiting_tx);
+ exited_tx
+ .send(pause.wait_for_pause_work(|| {
+ if let Some(waiting_tx) = waiting_tx.take() {
+ waiting_tx.send(()).unwrap();
+ }
+ None::<()>
+ }))
+ .unwrap();
+ });
+ let waiting = waiting_rx.recv_timeout(std::time::Duration::from_secs(30));
+ target.navigation_response_ready(1);
+ let exited = exited_rx.recv_timeout(std::time::Duration::from_secs(30));
+ if exited.is_err() {
+ target.pause_ref().close_target();
+ }
+ waiter.join().unwrap();
+ waiting.expect("waiter must enter the pause wait before response readiness");
+ assert_eq!(
+ exited.expect("response readiness must wake the pause loop"),
+ Err(RendererInspectorPauseExitReason::Navigation)
+ );
+ assert_navigation_exit(&target);
+ target.navigation_finished(1);
+ assert_debugging_enabled(&target);
+ }
+}
diff --git a/moli-renderer-v8/src/devtools/target.rs b/moli-renderer-v8/src/devtools/target.rs
index b6767d6c4..cb0fb80ab 100644
--- a/moli-renderer-v8/src/devtools/target.rs
+++ b/moli-renderer-v8/src/devtools/target.rs
@@ -93,7 +93,8 @@ impl Drop for RendererDevToolsTargetShutdownRegistration {
/// only ingress and lifecycle coordination; all V8 session access remains in
/// the renderer-local Inspector executor.
#[derive(Clone)]
-pub(crate) struct RendererDevToolsTargetHandle {
+#[doc(hidden)]
+pub struct RendererDevToolsTargetHandle {
pause: RendererInspectorPauseBridge,
main: RendererInspectorMainIngress,
io: RendererInspectorIoIngress,
diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rs
index f52835290..44e250da4 100644
--- a/moli-renderer-v8/src/lib.rs
+++ b/moli-renderer-v8/src/lib.rs
@@ -234,18 +234,19 @@ pub use runtime::{
RendererCaptureScreenshotRequest, RendererCapturedScreencastFrame, RendererCapturedScreenshot,
RendererCommandTurnCompletion, RendererCommandTurnOutput, RendererCountEntry,
RendererDedicatedWorkerTargetEvent, RendererDedicatedWorkerTargetInfo,
- RendererDevToolsAgentToken, RendererDevToolsMainCommandEnvelope, RendererDocumentBoxModel,
- RendererDocumentChildNodeSnapshotEvent, RendererDocumentChildNodeSnapshotEvents,
- RendererDocumentChildNodeSnapshots, RendererDocumentCommitPermit,
- RendererDocumentFrontendNodeIdsResolution, RendererDocumentHitTestResult,
- RendererDocumentIsolateAccountingDiagnostics, RendererDocumentLifecycleEvent,
- RendererDocumentLifecycleEventKind, RendererDocumentLifecycleIdentity,
- RendererDocumentLifecycleMilestone, RendererDocumentLifecycleSnapshot,
- RendererDocumentLifecycleWaitOutcome, RendererDocumentLifecycleWaiter,
- RendererDocumentNodeAttributesResolution, RendererDocumentNodeClientRect,
- RendererDocumentNodeGeometry, RendererDocumentNodePropertyResolution,
- RendererDocumentNodeReference, RendererDocumentNodeTextResolution, RendererDocumentOptions,
- RendererDocumentQuerySelectorNode, RendererDocumentQuerySelectorResolution,
+ RendererDevToolsAgentToken, RendererDevToolsMainCommandEnvelope, RendererDevToolsTargetHandle,
+ RendererDocumentBoxModel, RendererDocumentChildNodeSnapshotEvent,
+ RendererDocumentChildNodeSnapshotEvents, RendererDocumentChildNodeSnapshots,
+ RendererDocumentCommitPermit, RendererDocumentFrontendNodeIdsResolution,
+ RendererDocumentHitTestResult, RendererDocumentIsolateAccountingDiagnostics,
+ RendererDocumentLifecycleEvent, RendererDocumentLifecycleEventKind,
+ RendererDocumentLifecycleIdentity, RendererDocumentLifecycleMilestone,
+ RendererDocumentLifecycleSnapshot, RendererDocumentLifecycleWaitOutcome,
+ RendererDocumentLifecycleWaiter, RendererDocumentNodeAttributesResolution,
+ RendererDocumentNodeClientRect, RendererDocumentNodeGeometry,
+ RendererDocumentNodePropertyResolution, RendererDocumentNodeReference,
+ RendererDocumentNodeTextResolution, RendererDocumentOptions, RendererDocumentQuerySelectorNode,
+ RendererDocumentQuerySelectorResolution,
RendererDocumentQuerySelectorWithChildNodeSnapshotEvents,
RendererDocumentSourcedSameDocumentNavigation,
RendererDocumentSourcedTopLevelLocationNavigation, RendererDocumentTerminationReason,
diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rs
index 0880947fa..c22ab7d22 100644
--- a/moli-renderer-v8/src/runtime/mod.rs
+++ b/moli-renderer-v8/src/runtime/mod.rs
@@ -434,6 +434,7 @@ pub use crate::devtools::ingress::io::{
pub use crate::devtools::ingress::main::{
RendererRuntimeInspectorMainCommandCompletion, RendererRuntimeInspectorMainCommandRoute,
};
+pub use crate::devtools::target::RendererDevToolsTargetHandle;
pub(crate) use crate::renderer::PageVmInitStage;
pub(crate) use crate::service_worker_runtime::{
MaterializedServiceWorkerFetchResponseHead, ServiceWorkerClientFocus,
diff --git a/moli-renderer-v8/src/runtime/owner_local.rs b/moli-renderer-v8/src/runtime/owner_local.rs
index 15194cbda..2a5a590cf 100644
--- a/moli-renderer-v8/src/runtime/owner_local.rs
+++ b/moli-renderer-v8/src/runtime/owner_local.rs
@@ -271,6 +271,11 @@ impl RendererPageHandle {
self.devtools_target.pause_ref().is_pause_active()
}
+ #[doc(hidden)]
+ pub fn renderer_devtools_target(&self) -> super::RendererDevToolsTargetHandle {
+ self.devtools_target.clone()
+ }
+
/// Enqueues the DevTools IO-agent script policy without borrowing the
/// owner-resident `PageVm` that may currently be executing JavaScript.
#[doc(hidden)]
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 ed5490bc5..e0267d796 100644
--- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs
@@ -171,55 +171,60 @@ impl RendererInspectorSessionExecutorLocal {
return;
};
let mut prefer_main = true;
- while let Some(command) = self.target.pause_ref().wait_for_pause_work(|| {
- // These are actual posted owner tasks, not an environment-version
- // check. Service them in both pause modes, before a following
- // Inspector observation; they never execute page JavaScript.
- if let Some(invalidation) = self.target.io_ref().claim_environment_invalidation() {
- return Some(RendererInspectorNestedCommand::EnvironmentInvalidation(
- invalidation,
- ));
- }
- let command = match pause_loop_policy {
- crate::devtools::pause::RendererInspectorPauseLoopPolicy::IoOnly => self
- .target
- .io_ref()
- .claim_for_pause()
- .map(RendererInspectorNestedCommand::Io),
- crate::devtools::pause::RendererInspectorPauseLoopPolicy::MainAndIo
- if prefer_main =>
- {
- self.target
- .main_ref()
- .claim_for_pause()
- .map(RendererInspectorNestedCommand::Main)
- .or_else(|| {
- self.target
- .io_ref()
- .claim_for_pause()
- .map(RendererInspectorNestedCommand::Io)
- })
+ let exit_reason = loop {
+ let work = self.target.pause_ref().wait_for_pause_work(|| {
+ // These are actual posted owner tasks, not an environment-version
+ // check. Service them in both pause modes, before a following
+ // Inspector observation; they never execute page JavaScript.
+ if let Some(invalidation) = self.target.io_ref().claim_environment_invalidation() {
+ return Some(RendererInspectorNestedCommand::EnvironmentInvalidation(
+ invalidation,
+ ));
}
- crate::devtools::pause::RendererInspectorPauseLoopPolicy::MainAndIo => self
- .target
- .io_ref()
- .claim_for_pause()
- .map(RendererInspectorNestedCommand::Io)
- .or_else(|| {
+ let command = match pause_loop_policy {
+ crate::devtools::pause::RendererInspectorPauseLoopPolicy::IoOnly => self
+ .target
+ .io_ref()
+ .claim_for_pause()
+ .map(RendererInspectorNestedCommand::Io),
+ crate::devtools::pause::RendererInspectorPauseLoopPolicy::MainAndIo
+ if prefer_main =>
+ {
self.target
.main_ref()
.claim_for_pause()
.map(RendererInspectorNestedCommand::Main)
- }),
+ .or_else(|| {
+ self.target
+ .io_ref()
+ .claim_for_pause()
+ .map(RendererInspectorNestedCommand::Io)
+ })
+ }
+ crate::devtools::pause::RendererInspectorPauseLoopPolicy::MainAndIo => self
+ .target
+ .io_ref()
+ .claim_for_pause()
+ .map(RendererInspectorNestedCommand::Io)
+ .or_else(|| {
+ self.target
+ .main_ref()
+ .claim_for_pause()
+ .map(RendererInspectorNestedCommand::Main)
+ }),
+ };
+ if command.is_some()
+ && pause_loop_policy
+ == crate::devtools::pause::RendererInspectorPauseLoopPolicy::MainAndIo
+ {
+ prefer_main = !prefer_main;
+ }
+ command
+ });
+ let command = match work {
+ Ok(command) => command,
+ Err(reason) => break reason,
};
- if command.is_some()
- && pause_loop_policy
- == crate::devtools::pause::RendererInspectorPauseLoopPolicy::MainAndIo
- {
- prefer_main = !prefer_main;
- }
- command
- }) {
match command {
RendererInspectorNestedCommand::EnvironmentInvalidation(invalidation) => {
let isolate = unsafe { &mut *self.isolate.get() };
@@ -233,6 +238,23 @@ impl RendererInspectorSessionExecutorLocal {
self.dispatch_io_command(context_group_id, command);
}
}
+ };
+ if exit_reason == crate::devtools::pause::RendererInspectorPauseExitReason::Navigation {
+ // Like Chromium's UnpauseAndTerminate, unwind the paused old
+ // document before preparing its replacement on the owner thread.
+ // Later pauses observe the same provisional-load state until its
+ // explicit commit/cancel notification. No debugger setting leaks
+ // into the replacement document's Inspector restore snapshots.
+ let sessions: Vec<_> = self
+ .sessions
+ .borrow()
+ .iter()
+ .filter(|((group, _), _)| *group == context_group_id)
+ .filter_map(|(_, route)| route.session.upgrade())
+ .collect();
+ for session in sessions {
+ session.resume(true);
+ }
}
self.target.pause_ref().leave_pause();
}
diff --git a/vendor/v8-152.2.0/src/inspector.rs b/vendor/v8-152.2.0/src/inspector.rs
index 99ea3b89b..e60c2142d 100644
--- a/vendor/v8-152.2.0/src/inspector.rs
+++ b/vendor/v8-152.2.0/src/inspector.rs
@@ -82,6 +82,10 @@ unsafe extern "C" {
);
fn v8_inspector__V8InspectorSession__DELETE(this: *mut RawV8InspectorSession);
+ fn v8_inspector__V8InspectorSession__resume(
+ session: *mut RawV8InspectorSession,
+ terminate_on_resume: bool,
+ );
fn v8_inspector__V8InspectorSession__dispatchProtocolMessage(
session: *mut RawV8InspectorSession,
message: StringView,
@@ -965,6 +969,16 @@ impl V8InspectorSession {
}
}
+ /// Resumes paused execution, optionally terminating it as it unwinds.
+ pub fn resume(&self, terminate_on_resume: bool) {
+ unsafe {
+ v8_inspector__V8InspectorSession__resume(
+ self.raw.as_ptr(),
+ terminate_on_resume,
+ );
+ }
+ }
+
/// Cancel a pause previously scheduled by
/// [`Self::schedule_pause_on_next_statement`] if it hasn't fired yet.
pub fn cancel_pause_on_next_statement(&self) {
diff --git a/vendor/v8-152.2.0/src/inspector_session_ext.cc b/vendor/v8-152.2.0/src/inspector_session_ext.cc
index ea4a8f112..447f3a961 100644
--- a/vendor/v8-152.2.0/src/inspector_session_ext.cc
+++ b/vendor/v8-152.2.0/src/inspector_session_ext.cc
@@ -7,6 +7,11 @@ using namespace support;
extern "C" {
+void v8_inspector__V8InspectorSession__resume(
+ v8_inspector::V8InspectorSession* self, bool terminate_on_resume) {
+ self->resume(terminate_on_resume);
+}
+
void v8_inspector__V8InspectorSession__breakProgram(
v8_inspector::V8InspectorSession* self,
v8_inspector::StringView reason,