Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor(renderer): own document replacement debugger lifecycle

ldm0c4d0cac89af3
diff --git a/moli-core/src/page/document_content_support.rs b/moli-core/src/page/document_content_support.rs
index 7c8292d43..8b8e3114e 100644
--- a/moli-core/src/page/document_content_support.rs
+++ b/moli-core/src/page/document_content_support.rs
@@ -6,6 +6,16 @@ use super::{
};
impl Page {
+ /// Captures this document for a later renderer prepare operation. The
+ /// navigation's cancellation handle prevents abandoned work from starting
+ /// replacement; capturing this input does not resume a paused document.
+ pub fn document_replacement(
+ &self,
+ cancellation: moli_fetch::FetchCancelHandle,
+ ) -> crate::runtime::RendererDocumentReplacement {
+ self.handle.document_replacement(cancellation)
+ }
+
pub fn start_set_document_content(
&self,
frame_id: String,
diff --git a/moli-core/src/page/js_evaluation.rs b/moli-core/src/page/js_evaluation.rs
index b744f3f7e..df6641c64 100644
--- a/moli-core/src/page/js_evaluation.rs
+++ b/moli-core/src/page/js_evaluation.rs
@@ -594,11 +594,6 @@ 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 11b3a6187..c0ef0acd6 100644
--- a/moli-core/src/page/mod.rs
+++ b/moli-core/src/page/mod.rs
@@ -91,13 +91,12 @@ pub use moli_renderer_v8::{
RendererCaptureScreencastFrameReply, RendererCaptureScreencastFrameRequest,
RendererCaptureScreenshotReply, RendererCaptureScreenshotRequest,
RendererCommandTurnCompletion, RendererCommandTurnOutput, RendererDedicatedWorkerTargetEvent,
- RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken, RendererDevToolsTargetHandle,
- RendererDocumentHitTestResult, RendererDocumentIsolateAccountingDiagnostics,
- RendererDocumentLifecycleEvent, RendererDocumentLifecycleEventKind,
- RendererDocumentLifecycleIdentity, RendererDocumentLifecycleMilestone,
- RendererDocumentLifecycleSnapshot, RendererDocumentLifecycleWaitOutcome,
- RendererDocumentLifecycleWaiter, RendererDocumentNodeGeometry,
- RendererDocumentSourcedSameDocumentNavigation,
+ RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken, RendererDocumentHitTestResult,
+ RendererDocumentIsolateAccountingDiagnostics, RendererDocumentLifecycleEvent,
+ RendererDocumentLifecycleEventKind, RendererDocumentLifecycleIdentity,
+ RendererDocumentLifecycleMilestone, RendererDocumentLifecycleSnapshot,
+ RendererDocumentLifecycleWaitOutcome, RendererDocumentLifecycleWaiter,
+ RendererDocumentNodeGeometry, RendererDocumentSourcedSameDocumentNavigation,
RendererDocumentSourcedTopLevelLocationNavigation, RendererDocumentTerminationReason,
RendererDocumentToken, RendererDomAttributeMutation, RendererDomAttributeMutationOutcome,
RendererDomDebuggerDomBreakpointResolution, RendererDomDebuggerEventListener,
diff --git a/moli-core/src/runtime/mod.rs b/moli-core/src/runtime/mod.rs
index 3a5e635ed..1875e9032 100644
--- a/moli-core/src/runtime/mod.rs
+++ b/moli-core/src/runtime/mod.rs
@@ -40,8 +40,8 @@ pub use fetch_deadline::{FetchDeadline, FetchReadinessTimeout, FetchTimeoutPhase
pub use moli_renderer_v8::{
DetachedParserScriptFetchContinuation, RendererBrowserContextRuntime,
RendererBrowserContextRuntimeOwner, RendererBrowserContextRuntimeOwnerAccess,
- RendererLifecycleDecider, RendererLifecycleDecision, RendererLifecycleSnapshot,
- RendererPageReservationToken, RendererReservedServiceWorkerClient,
+ RendererDocumentReplacement, RendererLifecycleDecider, RendererLifecycleDecision,
+ RendererLifecycleSnapshot, RendererPageReservationToken, RendererReservedServiceWorkerClient,
RendererServiceWorkerMainResourceFetch, RendererSharedWorkerRuntimeDiagnostics,
};
pub use navigation_engine::{
diff --git a/moli-core/src/runtime/navigation_engine.rs b/moli-core/src/runtime/navigation_engine.rs
index 2bd6dd673..c96b3c891 100644
--- a/moli-core/src/runtime/navigation_engine.rs
+++ b/moli-core/src/runtime/navigation_engine.rs
@@ -22,9 +22,9 @@ use moli_fetch::{
use moli_page_types::{LayoutPolicy, OptionalResourceFetchMask};
use moli_renderer_v8::{
RendererBrowserContextRuntime, RendererBrowserContextRuntimeOwner,
- RendererBrowserContextRuntimeOwnerAccess, RendererReservedServiceWorkerClient,
- RendererServiceWorkerMainResourceFetch, RendererWebStorageHandles, SharedStorageBucketStore,
- WeakIndexedDbManager,
+ RendererBrowserContextRuntimeOwnerAccess, RendererDocumentReplacement,
+ RendererReservedServiceWorkerClient, RendererServiceWorkerMainResourceFetch,
+ RendererWebStorageHandles, SharedStorageBucketStore, WeakIndexedDbManager,
network::{
BrowserResourceRuntime, BrowserResourceRuntimeOwner, PageNetworkPolicy,
navigation::{DocumentFetchContextSeed, NavigationResourceLoader},
@@ -1710,6 +1710,7 @@ impl NavigationEngine {
let prepared = self
.prepare_streaming_raw_page_from_external_body_async(
page_reservation,
+ None,
cookie_store,
web_storage,
indexed_db_manager,
@@ -1750,6 +1751,7 @@ impl NavigationEngine {
async fn prepare_streaming_raw_page_from_external_body_async(
&mut self,
page_reservation: moli_renderer_v8::RendererPageReservationToken,
+ replacement: Option<RendererDocumentReplacement>,
cookie_store: SharedBrowserCookieStore,
web_storage: RendererWebStorageHandles,
indexed_db_manager: Option<WeakIndexedDbManager>,
@@ -1793,6 +1795,7 @@ impl NavigationEngine {
.js_runtime
.prepare_streaming_raw_document_from_external_body(
page_reservation,
+ replacement,
requested_url,
final_url,
navigation_initiator_url,
@@ -1961,6 +1964,7 @@ impl NavigationEngine {
pub async fn prepare_streaming_raw_page_from_external_body_with_storage_and_inspector_session_restores_async(
&mut self,
page_reservation: moli_renderer_v8::RendererPageReservationToken,
+ replacement: Option<RendererDocumentReplacement>,
storage: NavigationPageStorageHandles,
requested_url: Url,
final_url: Url,
@@ -1993,6 +1997,7 @@ impl NavigationEngine {
storage.into_parts();
self.prepare_streaming_raw_page_from_external_body_async(
page_reservation,
+ replacement,
cookie_store,
web_storage,
indexed_db_manager,
@@ -2099,6 +2104,7 @@ impl NavigationEngine {
async fn prepare_document_page_from_response_options_best_effort_async(
&mut self,
page_reservation: moli_renderer_v8::RendererPageReservationToken,
+ replacement: Option<RendererDocumentReplacement>,
cookie_store: SharedBrowserCookieStore,
web_storage: RendererWebStorageHandles,
indexed_db_manager: Option<WeakIndexedDbManager>,
@@ -2110,6 +2116,7 @@ impl NavigationEngine {
ExternalRawDocumentBodyStream::from_bytes(options.response_body.into_bytes());
self.prepare_streaming_raw_page_from_external_body_async(
page_reservation,
+ replacement,
cookie_store,
web_storage,
indexed_db_manager,
@@ -2156,6 +2163,7 @@ impl NavigationEngine {
let prepared = self
.prepare_document_page_from_response_options_best_effort_async(
page_reservation,
+ None,
cookie_store,
web_storage,
indexed_db_manager,
@@ -2172,6 +2180,7 @@ impl NavigationEngine {
pub async fn prepare_document_page_from_response_with_storage_and_inspector_session_restores_async(
&mut self,
page_reservation: moli_renderer_v8::RendererPageReservationToken,
+ replacement: Option<RendererDocumentReplacement>,
storage: NavigationPageStorageHandles,
requested_url: Url,
final_url: Url,
@@ -2201,6 +2210,7 @@ impl NavigationEngine {
storage.into_parts();
self.prepare_document_page_from_response_options_best_effort_async(
page_reservation,
+ replacement,
cookie_store,
web_storage,
indexed_db_manager,
diff --git a/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger.rs b/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger.rs
index 6b4f68bf6..b462404e8 100644
--- a/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger.rs
+++ b/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger.rs
@@ -331,22 +331,43 @@ async fn assert_delayed_navigation_while_paused(supersede: bool) {
#[tokio::test]
async fn navigation_cancellation_at_request_stage_preserves_the_paused_document_and_debugger() {
- assert_intercepted_navigation_while_paused("Request", InterceptionAction::Cancel).await;
+ assert_intercepted_navigation_while_paused("Request", InterceptionAction::Cancel, None).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;
+ assert_intercepted_navigation_while_paused("Response", InterceptionAction::Cancel, None).await;
}
#[tokio::test]
async fn navigation_continues_an_intercepted_response_while_debugger_is_paused() {
- assert_intercepted_navigation_while_paused("Response", InterceptionAction::Continue).await;
+ assert_intercepted_navigation_while_paused("Response", InterceptionAction::Continue, None)
+ .await;
}
#[tokio::test]
async fn navigation_fulfills_an_intercepted_response_while_debugger_is_paused() {
- assert_intercepted_navigation_while_paused("Response", InterceptionAction::Fulfill).await;
+ assert_intercepted_navigation_while_paused("Response", InterceptionAction::Fulfill, None).await;
+}
+
+#[tokio::test]
+async fn stale_response_continuation_preserves_the_paused_document_and_debugger() {
+ assert_intercepted_navigation_while_paused(
+ "Response",
+ InterceptionAction::Cancel,
+ Some(InterceptionAction::Continue),
+ )
+ .await;
+}
+
+#[tokio::test]
+async fn stale_response_fulfillment_preserves_the_paused_document_and_debugger() {
+ assert_intercepted_navigation_while_paused(
+ "Response",
+ InterceptionAction::Cancel,
+ Some(InterceptionAction::Fulfill),
+ )
+ .await;
}
#[derive(Clone, Copy)]
@@ -356,9 +377,31 @@ enum InterceptionAction {
Fulfill,
}
+impl InterceptionAction {
+ fn command(self, request_id: serde_json::Value) -> (&'static str, serde_json::Value) {
+ match self {
+ Self::Cancel => (
+ "Fetch.failRequest",
+ json!({"requestId": request_id, "errorReason": "Aborted"}),
+ ),
+ Self::Continue => ("Fetch.continueResponse", json!({"requestId": request_id})),
+ Self::Fulfill => (
+ "Fetch.fulfillRequest",
+ json!({
+ "requestId": request_id,
+ "responseCode": 200,
+ "responseHeaders": [{"name": "Content-Type", "value": "text/html"}],
+ "body": "PHRpdGxlPmZ1bGZpbGxlZDwvdGl0bGU+"
+ }),
+ ),
+ }
+ }
+}
+
async fn assert_intercepted_navigation_while_paused(
request_stage: &str,
action: InterceptionAction,
+ stale_response: Option<InterceptionAction>,
) {
let (fixture_addr, fixture) = spawn_dedicated_fixture_server(
Router::new().route(
@@ -413,32 +456,49 @@ async fn assert_intercepted_navigation_while_paused(
message["method"] == "Fetch.requestPaused"
})
.await;
- let request_id = intercepted
+ let mut 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 navigation_id = if let Some(stale_action) = stale_response {
+ send_cdp_command_without_wait(
+ &mut socket,
+ 20,
+ "Page.navigate",
+ Some(&session_id),
+ json!({"url": format!("http://{fixture_addr}/?replacement")}),
+ )
+ .await;
+ let replacement = recv_until_match(&mut socket, |message| {
+ message["method"] == "Fetch.requestPaused"
+ })
+ .await;
+ let replacement_id = replacement
+ .iter()
+ .find(|message| message["method"] == "Fetch.requestPaused")
+ .unwrap()["params"]["requestId"]
+ .clone();
+ assert_ne!(request_id, replacement_id);
+ let (method, params) = stale_action.command(request_id);
+ let stale = send_cdp_command(&mut socket, 21, method, Some(&session_id), params).await;
+ assert!(
+ stale
+ .iter()
+ .any(|message| message["id"] == 21 && message.get("error").is_none())
+ );
+ request_id = replacement_id;
+ 20
+ } else {
+ 9
};
+ let (method, params) = action.command(request_id);
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);
+ if !completed
+ .iter()
+ .any(|message| message["id"] == navigation_id)
+ {
+ completed.extend(recv_until_id(&mut socket, navigation_id).await);
}
assert!(
completed
@@ -471,7 +531,7 @@ async fn assert_intercepted_navigation_while_paused(
assert!(
completed
.iter()
- .any(|message| message["id"] == 9 && message.get("error").is_none())
+ .any(|message| message["id"] == navigation_id && message.get("error").is_none())
);
if !completed
.iter()
diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rs
index 8fedb47d1..4dda1e1a6 100644
--- a/moli-protocol/src/conn.rs
+++ b/moli-protocol/src/conn.rs
@@ -2830,12 +2830,7 @@ impl CdpConnection {
stage = "materialized_completion_drain_start",
);
}
- let is_current = completion.is_current_for_connection(self);
let (token, state, navigation) = completion.into_parts();
- if !is_current {
- crate::domains::page::push_superseded_navigation_result(out, &state);
- return;
- }
crate::domains::page::complete_materialized_navigation_into_buffer_async(
self,
out,
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 5a3444f81..7b2697428 100644
--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs
+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs
@@ -181,16 +181,10 @@ 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)>,
+ pub(crate) document_replacement: Option<moli_core::runtime::RendererDocumentReplacement>,
}
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,
@@ -353,7 +347,7 @@ impl TargetNavigationLoadInputs {
.navigation_history_state
.position_after_navigation(),
),
- renderer_navigation: target.runtime_slot().page_slot().renderer_navigation(),
+ document_replacement: None,
}
}
@@ -420,7 +414,7 @@ impl TargetNavigationLoadInputs {
permission_overrides: Vec::new(),
main_document_commit_seed: None,
session_history_position: None,
- renderer_navigation: None,
+ document_replacement: None,
}
}
diff --git a/moli-protocol/src/conn/fetch_support.rs b/moli-protocol/src/conn/fetch_support.rs
index 9065ce5fa..9aa4adc0e 100644
--- a/moli-protocol/src/conn/fetch_support.rs
+++ b/moli-protocol/src/conn/fetch_support.rs
@@ -1152,7 +1152,13 @@ impl PausedDocumentTransfer {
} => {
let navigation_state = navigation.clone();
let navigation = body
- .continue_navigation_async(conn, &navigation, response_code, response_headers)
+ .continue_navigation_async(
+ conn,
+ document_navigation_token.as_ref(),
+ &navigation,
+ response_code,
+ response_headers,
+ )
.await;
Ok((document_navigation_token, navigation_state, navigation))
}
@@ -1185,6 +1191,7 @@ impl PausedDocumentTransfer {
let navigation_state = navigation.clone();
let navigation = conn
.build_navigation_from_buffered_body_source_for_navigation_async(
+ document_navigation_token.as_ref(),
&navigation,
navigation.requested_url.clone(),
response_code,
@@ -1316,6 +1323,7 @@ impl ActiveDocumentBodyStreamState {
let final_url = self.response.final_url.clone();
let navigation = conn
.build_navigation_from_buffered_body_source_for_navigation_async(
+ self.document_navigation_token.as_ref(),
&self.navigation,
final_url,
response_code,
@@ -1490,6 +1498,7 @@ impl DocumentBodySource {
pub(crate) async fn continue_navigation_async(
self,
conn: &mut CdpConnection,
+ token: Option<&DocumentNavigationToken>,
navigation: &NavigationDispatchState,
response_code: Option<u16>,
response_headers: Vec<(String, Vec<u8>)>,
@@ -1503,6 +1512,7 @@ impl DocumentBodySource {
} => {
if !has_response_override {
conn.build_navigation_from_buffered_raw_response_for_navigation_async(
+ token,
navigation,
NetworkFetchResult::with_observation_journal(
response,
@@ -1521,6 +1531,7 @@ impl DocumentBodySource {
.expect("RawResponse body should remain materialized at the response override boundary");
let body = CapturedBody::from_bytes(body);
conn.build_navigation_from_buffered_body_source_for_navigation_async(
+ token,
navigation,
final_url,
response_code.unwrap_or(status),
@@ -1544,6 +1555,7 @@ impl DocumentBodySource {
..
} => {
conn.build_navigation_from_streaming_raw_response_with_response_override_for_navigation_async(
+ token,
navigation,
NetworkFetchResult::with_observation_journal(
response,
@@ -1564,6 +1576,7 @@ impl DocumentBodySource {
} => {
if !has_response_override {
conn.build_navigation_from_captured_raw_response_for_navigation_async(
+ token,
navigation,
head,
body,
@@ -1577,6 +1590,7 @@ impl DocumentBodySource {
let final_url = head.final_url.clone();
let request_cookie_report = head.request_cookie_report.clone();
conn.build_navigation_from_buffered_body_source_for_navigation_async(
+ token,
navigation,
final_url,
response_code.unwrap_or(status),
diff --git a/moli-protocol/src/conn/runtime_load.rs b/moli-protocol/src/conn/runtime_load.rs
index a20b57f07..1cfc9324e 100644
--- a/moli-protocol/src/conn/runtime_load.rs
+++ b/moli-protocol/src/conn/runtime_load.rs
@@ -1298,7 +1298,6 @@ 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();
@@ -1330,6 +1329,7 @@ async fn build_navigation_from_streaming_raw_response_with_engine_async(
let prepared_page = engine
.prepare_document_page_from_response_with_storage_and_inspector_session_restores_async(
page_reservation,
+ load_inputs.document_replacement.clone(),
page_storage.into_navigation_storage(),
requested_url.clone(),
final_url.clone(),
@@ -1399,6 +1399,7 @@ async fn build_navigation_from_streaming_raw_response_with_engine_async(
let prepared_future = engine
.prepare_streaming_raw_page_from_external_body_with_storage_and_inspector_session_restores_async(
page_reservation,
+ load_inputs.document_replacement.clone(),
page_storage.into_navigation_storage(),
requested_url.clone(),
final_url.clone(),
@@ -1477,6 +1478,30 @@ async fn build_navigation_from_streaming_raw_response_with_engine_async(
impl CdpConnection {
fn navigation_load_inputs_for_navigation(
+ &self,
+ token: Option<&DocumentNavigationToken>,
+ navigation: &NavigationDispatchState,
+ ) -> anyhow::Result<TargetNavigationLoadInputs> {
+ let token = token
+ .filter(|token| {
+ token.target_id == navigation.frame_id
+ && token.loader_id == navigation.loader_id
+ && self.accepts_pending_document_navigation_for_owner(&navigation.owner, token)
+ })
+ .ok_or_else(|| anyhow::anyhow!(moli_fetch::NET_ERR_ABORTED_ERROR_TEXT))?;
+ let mut inputs = self.navigation_request_load_inputs(navigation);
+ inputs.document_replacement = self
+ .runtime_session_owner_slot_for_owner(&navigation.owner)
+ .ok()
+ .and_then(|slot| {
+ let page_slot = slot.page_slot();
+ let cancellation = page_slot.document_navigation_cancellation_handle(token)?;
+ Some(page_slot.loaded_page()?.document_replacement(cancellation))
+ });
+ Ok(inputs)
+ }
+
+ fn navigation_request_load_inputs(
&self,
navigation: &NavigationDispatchState,
) -> TargetNavigationLoadInputs {
@@ -2093,12 +2118,13 @@ impl CdpConnection {
pub(crate) async fn load_navigation_request_via_runtime_with_network_events_for_navigation_async(
&mut self,
+ token: Option<&DocumentNavigationToken>,
navigation: &NavigationDispatchState,
body_progress_source: MainDocumentBodyProgressSource,
) -> anyhow::Result<NavigationLoadOutcome> {
self.load_navigation_request_via_runtime_with_network_events_and_load_inputs_async(
&navigation.owner,
- self.navigation_load_inputs_for_navigation(navigation),
+ self.navigation_load_inputs_for_navigation(token, navigation)?,
&navigation.request_method,
navigation.requested_url.as_str(),
navigation.clone_request_body_bytes(),
@@ -2111,6 +2137,7 @@ impl CdpConnection {
pub(crate) async fn prepare_navigation_load_error_for_navigation_async(
&mut self,
+ token: Option<&DocumentNavigationToken>,
navigation: &NavigationDispatchState,
error: anyhow::Error,
) -> anyhow::Result<NavigationLoadOutcome> {
@@ -2118,7 +2145,7 @@ impl CdpConnection {
return Err(error);
};
- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);
+ let load_inputs = self.navigation_load_inputs_for_navigation(token, navigation)?;
let mut engine = self.navigation_engine_handle_for_load_inputs(&load_inputs);
let page_reservation =
self.reserve_renderer_page_for_owner(&navigation.owner, &load_inputs, &engine);
@@ -2245,7 +2272,9 @@ impl CdpConnection {
early_result: Option<BackgroundNavigationEarlyResult>,
) -> Option<BackgroundNavigationLoadJob> {
let cancellation = self.document_navigation_cancellation_handle(token)?;
- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);
+ let load_inputs = self
+ .navigation_load_inputs_for_navigation(Some(token), navigation)
+ .ok()?;
// Ensure the target's resident browser resource runtime exists before
// cloning its engine handle. The job shares the target Page policy and
// retains this exact transport/cache owner for the captured navigation.
@@ -2288,20 +2317,28 @@ impl CdpConnection {
pub(crate) fn background_streaming_response_navigation_load_job_for_navigation(
&mut self,
+ token: &DocumentNavigationToken,
navigation: &NavigationDispatchState,
response: StreamingRawResponse,
network_observation_journal: NetworkObservationJournal,
response_code: Option<u16>,
response_headers_override: Vec<(String, Vec<u8>)>,
body_progress_source: MainDocumentBodyProgressSource,
- ) -> BackgroundStreamingResponseNavigationLoadJob {
- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);
+ ) -> Option<BackgroundStreamingResponseNavigationLoadJob> {
+ // Reject stale work before reserving a renderer Page or arming completion.
+ // Dropping the rejected response cancels only its own transport.
+ let load_inputs = self
+ .navigation_load_inputs_for_navigation(Some(token), navigation)
+ .ok()?;
+ if !self.arm_background_navigation_completion(token, Some(response.cancellation_handle())) {
+ return None;
+ }
let shared_resource_runtime =
self.shared_resource_runtime_for_navigation_load_inputs(&load_inputs);
let engine = self.navigation_engine_handle_for_load_inputs(&load_inputs);
let page_reservation =
self.reserve_renderer_page_for_owner(&navigation.owner, &load_inputs, &engine);
- BackgroundStreamingResponseNavigationLoadJob {
+ Some(BackgroundStreamingResponseNavigationLoadJob {
engine,
page_reservation,
load_inputs,
@@ -2314,7 +2351,7 @@ impl CdpConnection {
response_headers_override,
body_progress_source,
shared_resource_runtime,
- }
+ })
}
/// Reserves and binds the exact future Page before detached navigation work
@@ -2639,6 +2676,7 @@ impl CdpConnection {
pub(crate) async fn build_navigation_from_buffered_body_source_for_navigation_async(
&mut self,
+ token: Option<&DocumentNavigationToken>,
navigation: &NavigationDispatchState,
final_url: Url,
response_status: u16,
@@ -2648,7 +2686,7 @@ impl CdpConnection {
network_observation_journal: NetworkObservationJournal,
body_progress_source: MainDocumentBodyProgressSource,
) -> anyhow::Result<NavigationLoadOutcome> {
- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);
+ let load_inputs = self.navigation_load_inputs_for_navigation(token, navigation)?;
self.build_navigation_from_buffered_body_source_with_load_inputs_async(
&navigation.owner,
&load_inputs,
@@ -2849,7 +2887,7 @@ impl CdpConnection {
navigation: &NavigationDispatchState,
auth: SubresourceAuthCredentials,
) -> anyhow::Result<NetworkFetchResult<RawResponse>> {
- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);
+ let load_inputs = self.navigation_request_load_inputs(navigation);
let method = &navigation.request_method;
let raw_url = navigation.requested_url.as_str();
let body = navigation.clone_request_body_bytes();
@@ -2916,7 +2954,7 @@ impl CdpConnection {
navigation: &NavigationDispatchState,
auth: Option<SubresourceAuthCredentials>,
) -> anyhow::Result<NetworkFetchResult<StreamingRawResponse>> {
- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);
+ let load_inputs = self.navigation_request_load_inputs(navigation);
self.fetch_navigation_streaming_raw_response_with_load_inputs_async(
&load_inputs,
&navigation.request_method,
@@ -3149,10 +3187,11 @@ impl CdpConnection {
pub(crate) async fn build_navigation_from_buffered_raw_response_for_navigation_async(
&mut self,
+ token: Option<&DocumentNavigationToken>,
navigation: &NavigationDispatchState,
response: NetworkFetchResult<RawResponse>,
) -> anyhow::Result<NavigationLoadOutcome> {
- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);
+ let load_inputs = self.navigation_load_inputs_for_navigation(token, navigation)?;
self.build_navigation_from_buffered_raw_response_with_load_inputs_async(
&navigation.owner,
&load_inputs,
@@ -3204,13 +3243,14 @@ impl CdpConnection {
pub(crate) async fn build_navigation_from_captured_raw_response_for_navigation_async(
&mut self,
+ token: Option<&DocumentNavigationToken>,
navigation: &NavigationDispatchState,
head: ResponseHead,
body: CapturedBody,
network_observation_journal: NetworkObservationJournal,
body_progress_source: MainDocumentBodyProgressSource,
) -> anyhow::Result<NavigationLoadOutcome> {
- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);
+ let load_inputs = self.navigation_load_inputs_for_navigation(token, navigation)?;
self.build_navigation_from_captured_raw_response_with_load_inputs_async(
&navigation.owner,
&load_inputs,
@@ -3343,11 +3383,12 @@ impl CdpConnection {
pub(crate) async fn build_navigation_from_streaming_raw_response_for_navigation_async(
&mut self,
+ token: Option<&DocumentNavigationToken>,
navigation: &NavigationDispatchState,
response: NetworkFetchResult<StreamingRawResponse>,
body_progress_source: MainDocumentBodyProgressSource,
) -> anyhow::Result<NavigationLoadOutcome> {
- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);
+ let load_inputs = self.navigation_load_inputs_for_navigation(token, navigation)?;
self.build_navigation_from_streaming_raw_response_with_load_inputs_async(
&navigation.owner,
&load_inputs,
@@ -3364,13 +3405,14 @@ impl CdpConnection {
pub(crate) async fn build_navigation_from_streaming_raw_response_with_response_override_for_navigation_async(
&mut self,
+ token: Option<&DocumentNavigationToken>,
navigation: &NavigationDispatchState,
response: NetworkFetchResult<StreamingRawResponse>,
response_code: Option<u16>,
response_headers_override: Vec<(String, Vec<u8>)>,
body_progress_source: MainDocumentBodyProgressSource,
) -> anyhow::Result<NavigationLoadOutcome> {
- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);
+ let load_inputs = self.navigation_load_inputs_for_navigation(token, navigation)?;
self.build_navigation_from_streaming_raw_response_with_load_inputs_async(
&navigation.owner,
&load_inputs,
@@ -3598,7 +3640,6 @@ 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,
@@ -3656,6 +3697,7 @@ async fn prepare_captured_document_response_with_engine_async(
let prepared_future = engine
.prepare_streaming_raw_page_from_external_body_with_storage_and_inspector_session_restores_async(
page_reservation,
+ load_inputs.document_replacement.clone(),
page_storage.into_navigation_storage(),
requested_url.clone(),
final_url.clone(),
diff --git a/moli-protocol/src/conn/state/attachment_identity.rs b/moli-protocol/src/conn/state/attachment_identity.rs
index f1fd8bae8..163b7770f 100644
--- a/moli-protocol/src/conn/state/attachment_identity.rs
+++ b/moli-protocol/src/conn/state/attachment_identity.rs
@@ -36,10 +36,6 @@ 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/page_slot.rs b/moli-protocol/src/conn/state/page_slot.rs
index c9e3765a2..31d323344 100644
--- a/moli-protocol/src/conn/state/page_slot.rs
+++ b/moli-protocol/src/conn/state/page_slot.rs
@@ -84,24 +84,16 @@ 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,
- renderer_target: Option<moli_core::page::RendererDevToolsTargetHandle>,
- ) -> Self {
- if let Some(target) = &renderer_target {
- target.navigation_started(token.request_id.get());
- }
+ fn new(token: DocumentNavigationToken) -> Self {
Self {
token,
page_attachment_id: TargetPageAttachmentId::allocate(),
cancellation_handles: vec![moli_fetch::FetchCancelHandle::new()],
background_completion_pending: false,
committed: false,
- renderer_target,
}
}
@@ -135,14 +127,7 @@ impl PendingNavigationRequest {
self.cancellation_handles.clear();
}
- 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();
}
@@ -683,24 +668,10 @@ impl TargetPageSlot {
};
self.pending_renderer_page = None;
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,
- ));
+ self.pending_navigation_request = Some(PendingNavigationRequest::new(token.clone()));
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();
@@ -864,7 +835,6 @@ 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;
diff --git a/moli-protocol/src/conn/tests/mod.rs b/moli-protocol/src/conn/tests/mod.rs
index 55d053d9a..5ac234020 100644
--- a/moli-protocol/src/conn/tests/mod.rs
+++ b/moli-protocol/src/conn/tests/mod.rs
@@ -1568,18 +1568,32 @@ fn navigation_background_event_sender_preserves_typed_sidecar_for_current_token(
#[tokio::test]
async fn materialized_navigation_completion_drops_stale_token() {
+ assert_stale_completion_retires_renderer_suspension(false).await;
+}
+
+#[tokio::test]
+async fn stale_navigation_completion_releases_renderer_after_current_navigation_finishes() {
+ assert_stale_completion_retires_renderer_suspension(true).await;
+}
+
+async fn assert_stale_completion_retires_renderer_suspension(finish_current_first: bool) {
let mut conn = CdpConnection::new();
let mut browser_context = BrowserContext::new("CTX-nav".to_owned());
browser_context.set_active_target_id("TID-nav");
let stale = browser_context
.start_document_navigation_for_active_target("LOADER-1".to_owned())
.expect("active target should produce stale token");
- let _current = browser_context
+ let current = browser_context
.start_document_navigation_for_active_target("LOADER-2".to_owned())
.expect("active target should produce current token");
conn.install_browser_context_fixture_for_test(browser_context);
let state =
materialized_navigation_test_state(Some(7), "LOADER-1", "https://example.test/stale");
+ let owner = state.owner.clone();
+ if finish_current_first {
+ conn.finish_renderer_document_navigation_for_owner(&owner, &current)
+ .unwrap();
+ }
let navigation =
MaterializedNavigationLoadOutcome::Failed(MaterializedFailedDocumentProgress {
error_text: "stale navigation should not emit".to_owned(),
@@ -1616,6 +1630,13 @@ async fn materialized_navigation_completion_drops_stale_token() {
reply.get("method").is_none(),
"stale completion must emit a command reply, not an event"
);
+ assert!(conn.accepts_pending_document_navigation_for_owner(&owner, &current));
+ if !finish_current_first {
+ assert!(conn.renderer_document_navigation_is_suspended_for_session_owner(None));
+ conn.finish_renderer_document_navigation_for_owner(&owner, &current)
+ .unwrap();
+ }
+ assert!(!conn.renderer_document_navigation_is_suspended_for_session_owner(None));
}
#[tokio::test]
diff --git a/moli-protocol/src/conn/tests/navigation_error.rs b/moli-protocol/src/conn/tests/navigation_error.rs
index 7e85b99f1..f6bf27262 100644
--- a/moli-protocol/src/conn/tests/navigation_error.rs
+++ b/moli-protocol/src/conn/tests/navigation_error.rs
@@ -1,7 +1,7 @@
use super::*;
use crate::conn::{
- CommandOwnerScope, NavigationLoadOutcome, NavigationNetworkError, NavigationNetworkErrorKind,
- NavigationRequestLoadPolicy,
+ CommandOwnerScope, DocumentNavigationToken, NavigationLoadOutcome, NavigationNetworkError,
+ NavigationNetworkErrorKind, NavigationRequestLoadPolicy,
};
use moli_core::page::{SubresourceAuthCredentials, SubresourceAuthScheme, SubresourceAuthTarget};
@@ -45,7 +45,7 @@ fn failing_streamed_document(
#[tokio::test]
async fn fetch_body_materialization_preserves_error_type_and_request_identity() {
- let (_ctx, navigation) = navigation_fixture();
+ let (_ctx, _token, navigation) = navigation_fixture();
let (error, body) = failing_streamed_document(&navigation)
.materialize_body_limited_async(1024)
.await
@@ -75,7 +75,7 @@ async fn fetch_body_materialization_preserves_error_type_and_request_identity()
#[tokio::test]
async fn fetch_body_stream_read_preserves_error_type_and_paused_transfer() {
- let (_ctx, navigation) = navigation_fixture();
+ let (_ctx, _token, navigation) = navigation_fixture();
let body = failing_streamed_document(&navigation);
let transfer = crate::conn::PausedDocumentTransfer::pending(
"fetch-typed-error".to_owned(),
@@ -102,12 +102,16 @@ async fn fetch_body_stream_read_preserves_error_type_and_paused_transfer() {
assert!(format!("{error:#}").contains("failed to read page body from stream"));
}
-fn navigation_fixture() -> (TestContext, NavigationDispatchState) {
+fn navigation_fixture() -> (
+ TestContext,
+ DocumentNavigationToken,
+ NavigationDispatchState,
+) {
let mut ctx = TestContext::new();
let mut browser_context = BrowserContext::new("BID-1".to_owned());
browser_context.set_active_target_id("TID-1");
browser_context.attach_active_session("SID-1");
- browser_context
+ let token = browser_context
.start_document_navigation_for_active_target("LID-test".to_owned())
.expect("fixture navigation should start");
ctx.conn
@@ -134,12 +138,137 @@ fn navigation_fixture() -> (TestContext, NavigationDispatchState) {
timestamp: 0.0,
source_document_security: Default::default(),
};
- (ctx, navigation)
+ (ctx, token, navigation)
+}
+
+fn streaming_response_job(
+ conn: &mut CdpConnection,
+ token: &DocumentNavigationToken,
+ navigation: &NavigationDispatchState,
+) -> (
+ Option<crate::conn::runtime_load::BackgroundStreamingResponseNavigationLoadJob>,
+ moli_fetch::FetchCancelHandle,
+) {
+ let crate::conn::DocumentBodySource::StreamingRaw { response, .. } =
+ failing_streamed_document(navigation)
+ else {
+ unreachable!()
+ };
+ let cancellation = response.cancellation_handle();
+ let job = conn.background_streaming_response_navigation_load_job_for_navigation(
+ token,
+ navigation,
+ response,
+ Default::default(),
+ None,
+ Vec::new(),
+ Default::default(),
+ );
+ (job, cancellation)
+}
+
+#[tokio::test]
+async fn document_navigation_cancellation_requires_the_exact_pending_token() {
+ let (mut ctx, _, _) = navigation_fixture();
+ ctx.install_navigation_fixture_for_session_owner("about:blank", Some("SID-1"))
+ .await;
+ let slot = ctx
+ .conn
+ .browser_context
+ .as_mut()
+ .unwrap()
+ .active_page_target_mut()
+ .runtime_slot
+ .page_slot_mut();
+ let first = slot.start_document_navigation("TID-1".to_owned(), "LID-test".to_owned());
+ let first_cancellation = slot
+ .document_navigation_cancellation_handle(&first)
+ .unwrap();
+ assert!(!first_cancellation.is_cancelled());
+ let current = slot.start_document_navigation("TID-1".to_owned(), "LID-test".to_owned());
+ assert!(first_cancellation.is_cancelled());
+
+ for mismatch in [
+ first,
+ DocumentNavigationToken {
+ target_id: "other target".to_owned(),
+ ..current.clone()
+ },
+ DocumentNavigationToken {
+ loader_id: "other loader".to_owned(),
+ ..current.clone()
+ },
+ ] {
+ assert!(
+ slot.document_navigation_cancellation_handle(&mismatch)
+ .is_none()
+ );
+ }
+ let current_cancellation = slot
+ .document_navigation_cancellation_handle(&current)
+ .unwrap();
+ assert!(!current_cancellation.is_cancelled());
+ assert!(slot.commit_pending_document_navigation_if_matches(&current));
+ assert!(
+ slot.document_navigation_cancellation_handle(&current)
+ .is_none()
+ );
+ assert!(!current_cancellation.is_cancelled());
+}
+
+#[tokio::test]
+async fn superseded_streaming_response_cannot_arm_the_current_navigation() {
+ let (mut ctx, stale, navigation) = navigation_fixture();
+ // Even reusing the target, loader and URL must not reuse a request's authority.
+ let current = ctx
+ .conn
+ .browser_context
+ .as_mut()
+ .unwrap()
+ .start_document_navigation_for_active_target(navigation.loader_id.clone())
+ .unwrap();
+ let current_cancellation = ctx
+ .conn
+ .document_navigation_cancellation_handle(&current)
+ .unwrap();
+ assert_ne!(stale.request_id, current.request_id);
+
+ let (job, stale_cancellation) = streaming_response_job(&mut ctx.conn, &stale, &navigation);
+ assert!(
+ job.is_none(),
+ "stale responses must not create renderer preparation jobs"
+ );
+ assert!(stale_cancellation.is_cancelled());
+ assert!(!current_cancellation.is_cancelled());
+ assert!(!ctx.conn.has_inflight_background_navigation());
+
+ let (job, _) = streaming_response_job(&mut ctx.conn, &current, &navigation);
+ assert!(
+ job.is_some(),
+ "the matching response must still be accepted"
+ );
+ assert!(ctx.conn.has_inflight_background_navigation());
+}
+
+#[tokio::test]
+async fn duplicate_streaming_response_does_not_cancel_the_armed_navigation() {
+ let (mut ctx, token, navigation) = navigation_fixture();
+ let (first, first_cancellation) = streaming_response_job(&mut ctx.conn, &token, &navigation);
+ assert!(first.is_some());
+ let (duplicate, duplicate_cancellation) =
+ streaming_response_job(&mut ctx.conn, &token, &navigation);
+ assert!(
+ duplicate.is_none(),
+ "an already armed request must not spawn another job"
+ );
+ assert!(duplicate_cancellation.is_cancelled());
+ assert!(!first_cancellation.is_cancelled());
+ assert!(ctx.conn.has_inflight_background_navigation());
}
#[tokio::test(flavor = "multi_thread")]
async fn offline_navigation_loaders_preserve_typed_error_causes_through_context() {
- let (mut ctx, mut navigation) = navigation_fixture();
+ let (mut ctx, token, mut navigation) = navigation_fixture();
navigation.request_method = "POST".to_owned();
navigation.request_headers =
moli_fetch::RequestHeaders::from_bytes(vec![("x-request".to_owned(), vec![0xe9, 0xff])]);
@@ -161,6 +290,7 @@ async fn offline_navigation_loaders_preserve_typed_error_causes_through_context(
let errors = [
ctx.conn
.load_navigation_request_via_runtime_with_network_events_for_navigation_async(
+ Some(&token),
&navigation,
Default::default(),
)
@@ -211,7 +341,7 @@ async fn offline_navigation_loaders_preserve_typed_error_causes_through_context(
#[tokio::test(flavor = "multi_thread")]
async fn navigation_error_document_uses_typed_failure_request_after_context() {
- let (mut ctx, navigation) = navigation_fixture();
+ let (mut ctx, token, navigation) = navigation_fixture();
let unreachable_url = Url::parse("https://overridden.example/unreachable").unwrap();
let request_headers = vec![("x-request".to_owned(), "overridden-request".to_owned())];
let error = anyhow::Error::new(NavigationNetworkError {
@@ -224,7 +354,7 @@ async fn navigation_error_document_uses_typed_failure_request_after_context() {
.context("failed to continue intercepted navigation");
let outcome = ctx
.conn
- .prepare_navigation_load_error_for_navigation_async(&navigation, error)
+ .prepare_navigation_load_error_for_navigation_async(Some(&token), &navigation, error)
.await
.expect("typed network failure should prepare an error document");
let NavigationLoadOutcome::ResponseCommitReady(prepared) = outcome else {
@@ -247,7 +377,7 @@ async fn navigation_error_document_uses_typed_failure_request_after_context() {
#[tokio::test(flavor = "multi_thread")]
async fn navigation_error_boundary_does_not_classify_display_text_as_network_failure() {
- let (mut ctx, navigation) = navigation_fixture();
+ let (mut ctx, token, navigation) = navigation_fixture();
for error in [
anyhow::anyhow!(OFFLINE_ERROR_TEXT),
anyhow::anyhow!(OFFLINE_ERROR_TEXT)
@@ -257,7 +387,7 @@ async fn navigation_error_boundary_does_not_classify_display_text_as_network_fai
let expected_chain = format!("{error:#}");
let error = ctx
.conn
- .prepare_navigation_load_error_for_navigation_async(&navigation, error)
+ .prepare_navigation_load_error_for_navigation_async(Some(&token), &navigation, error)
.await
.expect_err("a matching display string must remain a non-network error");
assert!(error.downcast_ref::<NavigationNetworkError>().is_none());
diff --git a/moli-protocol/src/conn/tests/resource_runtime.rs b/moli-protocol/src/conn/tests/resource_runtime.rs
index 4141f8cfc..aa9247ee7 100644
--- a/moli-protocol/src/conn/tests/resource_runtime.rs
+++ b/moli-protocol/src/conn/tests/resource_runtime.rs
@@ -91,7 +91,7 @@ async fn buffered_navigation_for_inactive_session_retains_its_target_engine() {
target_context.set_active_target_id("TID-target");
target_context.attach_active_session("SID-target");
target_context.begin_active_target_initial_empty_document("about:blank".to_owned());
- target_context
+ let token = target_context
.start_document_navigation_for_active_target("LOADER-target".to_owned())
.expect("target should accept its synthetic navigation");
conn.push_inactive_browser_context_fixture_for_test(target_context);
@@ -128,6 +128,7 @@ async fn buffered_navigation_for_inactive_session_retains_its_target_engine() {
let outcome = conn
.build_navigation_from_buffered_body_source_for_navigation_async(
+ Some(&token),
&navigation,
requested_url,
200,
diff --git a/moli-protocol/src/domains/fetch/commands.rs b/moli-protocol/src/domains/fetch/commands.rs
index 1c5887273..6a4d2bce4 100644
--- a/moli-protocol/src/domains/fetch/commands.rs
+++ b/moli-protocol/src/domains/fetch/commands.rs
@@ -1199,6 +1199,7 @@ pub(super) async fn complete_fulfill_request_command_async(
let navigation_state = pending.navigation;
let navigation = conn
.build_navigation_from_buffered_body_source_for_navigation_async(
+ token.as_ref(),
&navigation_state,
navigation_state.requested_url.clone(),
response_code,
@@ -1873,16 +1874,28 @@ fn continue_streaming_document_response_in_background(
network_observation_journal,
body_progress_source,
} = pending;
- let cancellation = response.cancellation_handle();
- let job = conn.background_streaming_response_navigation_load_job_for_navigation(
+ let Some(job) = conn.background_streaming_response_navigation_load_job_for_navigation(
+ &document_navigation_token,
&navigation,
response,
network_observation_journal,
response_code,
response_headers,
body_progress_source,
- );
- conn.arm_background_navigation_completion(&document_navigation_token, Some(cancellation));
+ ) else {
+ // An already-armed current request keeps its original completion.
+ if !conn.accepts_pending_document_navigation_for_owner(
+ &navigation.owner,
+ &document_navigation_token,
+ ) {
+ let _ = sender.send(page::BackgroundNavigationCompletion::new(
+ document_navigation_token,
+ navigation,
+ Err(anyhow::anyhow!(moli_fetch::NET_ERR_ABORTED_ERROR_TEXT)),
+ ));
+ }
+ return;
+ };
tokio::task::spawn_local(async move {
let body_completion_sink = BackgroundNavigationBodyCompletionSink::new(
sender.clone(),
diff --git a/moli-protocol/src/domains/fetch/navigation.rs b/moli-protocol/src/domains/fetch/navigation.rs
index 9127d0740..a6ec8df84 100644
--- a/moli-protocol/src/domains/fetch/navigation.rs
+++ b/moli-protocol/src/domains/fetch/navigation.rs
@@ -170,6 +170,7 @@ pub(crate) async fn load_or_pause_navigation_for_auth_into_buffer_async(
} else {
let navigation = conn
.build_navigation_from_buffered_raw_response_for_navigation_async(
+ pending.document_navigation_token.as_ref(),
&pending.navigation,
response,
)
@@ -224,6 +225,7 @@ pub(crate) async fn load_or_pause_navigation_for_auth_into_buffer_async(
let navigation = conn
.load_navigation_request_via_runtime_with_network_events_for_navigation_async(
+ pending.document_navigation_token.as_ref(),
&pending.navigation,
network::MainDocumentBodyProgressSource::default(),
)
@@ -324,6 +326,7 @@ pub(super) async fn cancel_navigation_auth_as_background_events_async(
pending.intercept_response = false;
let navigation = conn
.build_navigation_from_buffered_raw_response_for_navigation_async(
+ pending.document_navigation_token.as_ref(),
&pending.navigation,
response,
)
@@ -410,6 +413,7 @@ async fn complete_pending_fetch_navigation_result_into_buffer_async(
let navigation = match navigation {
Err(error) => {
Box::pin(conn.prepare_navigation_load_error_for_navigation_async(
+ token.as_ref(),
&navigation_state,
error.context("failed to continue intercepted navigation"),
))
@@ -482,6 +486,7 @@ async fn handle_streaming_response_head_for_navigation_into_buffer_async(
if response_headers_indicate_attachment_download(&response_head.headers) {
let navigation = conn
.build_navigation_from_streaming_raw_response_for_navigation_async(
+ pending.document_navigation_token.as_ref(),
&pending.navigation,
response,
network::MainDocumentBodyProgressSource::default(),
@@ -495,6 +500,7 @@ async fn handle_streaming_response_head_for_navigation_into_buffer_async(
if !prepare_navigation_response_stage(conn, &mut pending, &response_head.final_url) {
let navigation = conn
.build_navigation_from_streaming_raw_response_for_navigation_async(
+ pending.document_navigation_token.as_ref(),
&pending.navigation,
response,
network::MainDocumentBodyProgressSource::default(),
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 a45cf0a97..47d5972d4 100644
--- a/moli-protocol/src/domains/fetch/tests/navigation_response_stage.rs
+++ b/moli-protocol/src/domains/fetch/tests/navigation_response_stage.rs
@@ -840,6 +840,15 @@ 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_response() {
+ assert_interleaved_response_heads(false).await;
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn interleaved_response_heads_preserve_the_current_debugger_pause() {
+ assert_interleaved_response_heads(true).await;
+}
+
+async fn assert_interleaved_response_heads(pause_old_document: bool) {
async fn first() -> impl IntoResponse {
(
[(CONTENT_TYPE.as_str(), "text/html")],
@@ -874,6 +883,21 @@ async fn interleaved_response_heads_only_commit_the_current_response() {
.enable_primary_network_events();
ctx.conn.install_browser_context_fixture_for_test(bc);
+ if pause_old_document {
+ ctx.install_navigation_fixture_for_session_owner(
+ "data:text/html,<title>old document</title>",
+ Some("SID-1"),
+ )
+ .await;
+ ctx.process_async(json!({
+ "id": 360,
+ "method": "Debugger.enable",
+ "sessionId": "SID-1"
+ }))
+ .await;
+ ctx.sent.clear();
+ }
+
ctx.process_async(json!({
"id": 364,
"method": "Fetch.enable",
@@ -889,6 +913,23 @@ async fn interleaved_response_heads_only_commit_the_current_response() {
.await;
ctx.expect_result(364, json!({}), Some("SID-1"));
+ if pause_old_document {
+ ctx.process_async(json!({
+ "id": 361,
+ "method": "Runtime.evaluate",
+ "sessionId": "SID-1",
+ "params": {
+ "expression": "setTimeout(() => { debugger; globalThis.resumedNormally = true; }, 0)"
+ }
+ }))
+ .await;
+ ctx.wait_for_scheduler_message("old document debugger pause", |message| {
+ message["method"] == "Debugger.paused"
+ })
+ .await;
+ ctx.sent.clear();
+ }
+
ctx.process_async(json!({
"id": 365,
"method": "Page.navigate",
@@ -947,11 +988,8 @@ async fn interleaved_response_heads_only_commit_the_current_response() {
.await;
ctx.expect_result(367, json!({}), Some("SID-1"));
let superseded = take_response_by_id(&mut ctx, 365);
- assert_eq!(superseded["error"]["code"], -32000);
- assert_eq!(
- superseded["error"]["message"],
- "renderer channel navigation was superseded by a newer navigation"
- );
+ assert!(superseded.get("error").is_none());
+ assert_eq!(superseded["result"]["errorText"], "net::ERR_ABORTED");
assert_eq!(
ctx.conn.browser_context.as_ref().and_then(|bc| bc
.active_page_target()
@@ -961,6 +999,55 @@ async fn interleaved_response_heads_only_commit_the_current_response() {
"a superseded response head must not switch the renderer channel"
);
+ if pause_old_document {
+ assert!(
+ ctx.conn
+ .browser_context
+ .as_ref()
+ .unwrap()
+ .loaded_page()
+ .unwrap()
+ .runtime_inspector_pause_active(),
+ "continuing stale A must not terminate the old document while B is intercepted"
+ );
+ ctx.process_async(json!({
+ "id": 368,
+ "method": "Fetch.failRequest",
+ "sessionId": "SID-1",
+ "params": { "requestId": second_request_id, "errorReason": "Aborted" }
+ }))
+ .await;
+ ctx.expect_result(368, json!({}), Some("SID-1"));
+ ctx.process_async(json!({
+ "id": 369,
+ "method": "Debugger.resume",
+ "sessionId": "SID-1"
+ }))
+ .await;
+ ctx.expect_result(369, json!({}), Some("SID-1"));
+ ctx.process_async(json!({
+ "id": 370,
+ "method": "Runtime.evaluate",
+ "sessionId": "SID-1",
+ "params": {
+ "expression": "document.title + ':' + globalThis.resumedNormally",
+ "returnByValue": true
+ }
+ }))
+ .await;
+ assert_eq!(
+ take_response_by_id(&mut ctx, 370)["result"]["result"]["value"],
+ "old document:true"
+ );
+ assert!(
+ !ctx.sent
+ .iter()
+ .any(|message| message["method"] == "Page.frameNavigated")
+ );
+ server.abort();
+ return;
+ }
+
ctx.process_async(json!({
"id": 368,
"method": "Fetch.continueResponse",
diff --git a/moli-protocol/src/domains/page/navigation.rs b/moli-protocol/src/domains/page/navigation.rs
index 2e50aba8b..a1478aeb8 100644
--- a/moli-protocol/src/domains/page/navigation.rs
+++ b/moli-protocol/src/domains/page/navigation.rs
@@ -403,10 +403,6 @@ impl MaterializedNavigationCompletion {
}
}
- pub(crate) fn is_current_for_connection(&self, conn: &CdpConnection) -> bool {
- conn.accepts_pending_document_navigation_for_owner(&self.state.owner, &self.token)
- }
-
pub(crate) fn requested_url(&self) -> &str {
self.state.requested_url.as_str()
}
@@ -3219,6 +3215,13 @@ pub(crate) async fn complete_materialized_navigation_into_buffer_async(
navigation: network::MaterializedNavigationLoadOutcome,
command_context: &mut crate::conn::CommandDispatchContext,
) {
+ if !conn.accepts_pending_document_navigation_for_owner(&state.owner, &token) {
+ push_superseded_navigation_result(out, &state);
+ // A stale response cannot commit or alter the current navigation, but
+ // its exact renderer-channel suspension still needs to be retired.
+ finish_renderer_navigation_into_buffer_async(conn, out, &state.owner, &token).await;
+ return;
+ }
complete_materialized_navigation_into_buffer_inner_async(
conn,
out,
@@ -3239,7 +3242,6 @@ async fn complete_materialized_navigation_into_buffer_inner_async(
command_context: &mut crate::conn::CommandDispatchContext,
) {
let navigation_owner = state.owner.clone();
- let navigation_session_id = navigation_owner.session_id().map(str::to_owned);
let navigation_loader_id = state.loader_id.clone();
match navigation {
network::MaterializedNavigationLoadOutcome::ResponseCommitReady(navigation) => {
@@ -3354,11 +3356,25 @@ async fn complete_materialized_navigation_into_buffer_inner_async(
.emit_navigation_error_into_buffer(out, &error_text);
}
}
+ finish_renderer_navigation_into_buffer_async(conn, out, &navigation_owner, &token).await;
+ conn.clear_pending_document_navigation_for_owner_if_loader_matches(
+ &navigation_owner,
+ &navigation_loader_id,
+ );
+}
+
+async fn finish_renderer_navigation_into_buffer_async(
+ conn: &mut CdpConnection,
+ out: &mut CommandOutputBuffer,
+ owner: &CommandOwnerScope,
+ token: &DocumentNavigationToken,
+) {
+ let navigation_session_id = owner.session_id().map(str::to_owned);
let primary_protocol_session_id = conn
- .runtime_session_owner_primary_session_id_for_owner(&navigation_owner)
+ .runtime_session_owner_primary_session_id_for_owner(owner)
.or_else(|| navigation_session_id.clone());
let (routed_renderer_output, renderer_call_replacements) = conn
- .finish_renderer_document_navigation_for_owner(&navigation_owner, &token)
+ .finish_renderer_document_navigation_for_owner(owner, token)
.map(|finish| (finish.released_output, finish.renderer_call_replacements))
.unwrap_or_default();
if !routed_renderer_output.is_empty() {
@@ -3390,10 +3406,6 @@ async fn complete_materialized_navigation_into_buffer_inner_async(
),
}
}
- conn.clear_pending_document_navigation_for_owner_if_loader_matches(
- &navigation_owner,
- &navigation_loader_id,
- );
}
fn push_navigation_commit_error(
diff --git a/moli-renderer-v8/src/devtools/pause/loop_state.rs b/moli-renderer-v8/src/devtools/pause/loop_state.rs
index ff13b5af8..fe7ff1916 100644
--- a/moli-renderer-v8/src/devtools/pause/loop_state.rs
+++ b/moli-renderer-v8/src/devtools/pause/loop_state.rs
@@ -21,7 +21,7 @@ pub(crate) enum RendererInspectorPauseLoopPolicy {
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum RendererInspectorPauseExitReason {
Resumed,
- Navigation,
+ DocumentReplacement,
SessionDetached,
TargetClosed,
}
diff --git a/moli-renderer-v8/src/devtools/pause/mod.rs b/moli-renderer-v8/src/devtools/pause/mod.rs
index 58d1fe754..6159643be 100644
--- a/moli-renderer-v8/src/devtools/pause/mod.rs
+++ b/moli-renderer-v8/src/devtools/pause/mod.rs
@@ -24,7 +24,6 @@ use crate::runtime::{
mod causality;
mod loop_state;
-mod navigation;
use causality::{
RendererInspectorPauseCommandDispatch, RendererInspectorPauseCommandTransition,
@@ -35,7 +34,6 @@ pub(crate) use causality::{
};
use loop_state::RendererInspectorPausePhase;
pub(crate) use loop_state::{RendererInspectorPauseExitReason, RendererInspectorPauseLoopPolicy};
-use navigation::RendererProvisionalLoad;
#[derive(Clone)]
pub(crate) struct RendererInspectorPauseBridge {
@@ -58,7 +56,7 @@ struct RendererInspectorPauseBridgeState {
pause_loop_policy: RendererInspectorPauseLoopPolicy,
quit_requested: bool,
session_detach_arms: usize,
- provisional_load: Option<RendererProvisionalLoad>,
+ document_replacements: usize,
target_closed: bool,
pending_prefaces: VecDeque<RendererInspectorPausePreface>,
paused_sessions_awaiting_resumed: HashSet<(RendererDevToolsAgentToken, DevToolsSessionKey)>,
@@ -128,7 +126,7 @@ impl RendererInspectorPauseBridge {
pause_loop_policy: RendererInspectorPauseLoopPolicy::MainAndIo,
quit_requested: false,
session_detach_arms: 0,
- provisional_load: None,
+ document_replacements: 0,
target_closed: false,
pending_prefaces: VecDeque::new(),
paused_sessions_awaiting_resumed: HashSet::new(),
@@ -151,7 +149,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("document_replacements", &state.document_replacements)
.field("target_closed", &state.target_closed)
.field("pending_prefaces", &state.pending_prefaces.len())
.field(
@@ -364,6 +362,24 @@ impl RendererInspectorPauseBridge {
Some(state.pause_loop_policy)
}
+ pub(crate) fn begin_document_replacement(&self) -> bool {
+ let mut state = self.shared.state.lock();
+ if state.target_closed {
+ return false;
+ }
+ state.document_replacements += 1;
+ self.shared.pause_loop_wake.notify_all();
+ true
+ }
+
+ pub(crate) fn finish_document_replacement(&self) {
+ let mut state = self.shared.state.lock();
+ state.document_replacements = state
+ .document_replacements
+ .checked_sub(1)
+ .expect("document replacement scope must be balanced");
+ }
+
pub(crate) fn wait_for_pause_work<T>(
&self,
mut claim: impl FnMut() -> Option<T>,
@@ -373,11 +389,8 @@ impl RendererInspectorPauseBridge {
if state.target_closed {
return Err(RendererInspectorPauseExitReason::TargetClosed);
}
- if matches!(
- state.provisional_load,
- Some(RendererProvisionalLoad::ReplacingDocument(_))
- ) {
- return Err(RendererInspectorPauseExitReason::Navigation);
+ if state.document_replacements != 0 {
+ return Err(RendererInspectorPauseExitReason::DocumentReplacement);
}
if state.session_detach_arms != 0 {
return Err(RendererInspectorPauseExitReason::SessionDetached);
diff --git a/moli-renderer-v8/src/devtools/pause/navigation.rs b/moli-renderer-v8/src/devtools/pause/navigation.rs
deleted file mode 100644
index 07fcbc6aa..000000000
--- a/moli-renderer-v8/src/devtools/pause/navigation.rs
+++ /dev/null
@@ -1,206 +0,0 @@
-#[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/lib.rs b/moli-renderer-v8/src/lib.rs
index 44e250da4..4f6db92af 100644
--- a/moli-renderer-v8/src/lib.rs
+++ b/moli-renderer-v8/src/lib.rs
@@ -234,20 +234,19 @@ pub use runtime::{
RendererCaptureScreenshotRequest, RendererCapturedScreencastFrame, RendererCapturedScreenshot,
RendererCommandTurnCompletion, RendererCommandTurnOutput, RendererCountEntry,
RendererDedicatedWorkerTargetEvent, RendererDedicatedWorkerTargetInfo,
- 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,
+ 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,
+ RendererDocumentQuerySelectorWithChildNodeSnapshotEvents, RendererDocumentReplacement,
RendererDocumentSourcedSameDocumentNavigation,
RendererDocumentSourcedTopLevelLocationNavigation, RendererDocumentTerminationReason,
RendererDocumentTitleChanged, RendererDocumentToken, RendererDomAttributeMutation,
diff --git a/moli-renderer-v8/src/runtime/document_replacement.rs b/moli-renderer-v8/src/runtime/document_replacement.rs
new file mode 100644
index 000000000..42ff84356
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/document_replacement.rs
@@ -0,0 +1,53 @@
+//! The old document's part of preparing a replacement document.
+//!
+//! Capturing a replacement is inert. The renderer preparation boundary starts
+//! the scope before queuing owner work, since the owner may be inside V8's pause
+//! loop. Prepared-document ownership keeps it alive until commit or cancellation.
+
+use std::sync::Arc;
+
+use crate::devtools::pause::RendererInspectorPauseBridge;
+
+#[derive(Clone, Debug)]
+pub struct RendererDocumentReplacement {
+ pause: RendererInspectorPauseBridge,
+ cancellation: moli_fetch::FetchCancelHandle,
+}
+
+impl RendererDocumentReplacement {
+ pub(super) fn new(
+ pause: RendererInspectorPauseBridge,
+ cancellation: moli_fetch::FetchCancelHandle,
+ ) -> Self {
+ Self {
+ pause,
+ cancellation,
+ }
+ }
+
+ pub(super) fn begin(self) -> anyhow::Result<Arc<RendererDocumentReplacementScope>> {
+ anyhow::ensure!(
+ !self.cancellation.is_cancelled() && self.pause.begin_document_replacement(),
+ moli_fetch::NET_ERR_ABORTED_ERROR_TEXT,
+ );
+ Ok(Arc::new(RendererDocumentReplacementScope {
+ pause: self.pause,
+ }))
+ }
+}
+
+/// Owned by the prepare command and its returned handle, not by protocol or by
+/// clones of the inert replacement input. Overlapping prepares for one old
+/// document remain independent; completing either one must not release the other.
+pub(crate) struct RendererDocumentReplacementScope {
+ pause: RendererInspectorPauseBridge,
+}
+
+impl Drop for RendererDocumentReplacementScope {
+ fn drop(&mut self) {
+ self.pause.finish_document_replacement();
+ }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/moli-renderer-v8/src/runtime/document_replacement/tests.rs b/moli-renderer-v8/src/runtime/document_replacement/tests.rs
new file mode 100644
index 000000000..40a930638
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/document_replacement/tests.rs
@@ -0,0 +1,344 @@
+use super::*;
+use crate::devtools::pause::RendererInspectorPauseExitReason;
+
+fn replacement(pause: &RendererInspectorPauseBridge) -> RendererDocumentReplacement {
+ RendererDocumentReplacement::new(pause.clone(), moli_fetch::FetchCancelHandle::new())
+}
+
+fn assert_debugging_enabled(pause: &RendererInspectorPauseBridge) {
+ assert_eq!(pause.wait_for_pause_work(|| Some(42)), Ok(42));
+}
+
+fn assert_replacement_exit(pause: &RendererInspectorPauseBridge) {
+ assert_eq!(
+ pause.wait_for_pause_work(|| Some(42)),
+ Err(RendererInspectorPauseExitReason::DocumentReplacement)
+ );
+}
+
+#[test]
+fn capturing_and_dropping_replacement_inputs_never_disturbs_the_old_document() {
+ let pause = RendererInspectorPauseBridge::default();
+ let input = replacement(&pause);
+ assert_debugging_enabled(&pause);
+ drop(input.clone());
+ assert_debugging_enabled(&pause);
+ drop(input);
+ assert_debugging_enabled(&pause);
+}
+
+#[test]
+fn canceled_input_cannot_start_replacement_even_if_captured_before_cancellation() {
+ let pause = RendererInspectorPauseBridge::default();
+ let input = replacement(&pause);
+ let retained = input.clone();
+ input.cancellation.cancel();
+ assert!(input.begin().is_err());
+ assert!(retained.begin().is_err());
+ assert_debugging_enabled(&pause);
+}
+
+#[test]
+fn scope_drop_restores_debugging_without_waiting_for_retained_inputs() {
+ let pause = RendererInspectorPauseBridge::default();
+ let input = replacement(&pause);
+ let scope = input.clone().begin().unwrap();
+ assert_replacement_exit(&pause);
+ drop(scope);
+ assert_debugging_enabled(&pause);
+ drop(input);
+ assert_debugging_enabled(&pause);
+}
+
+#[test]
+fn command_and_prepared_handle_share_one_scope_until_both_release_it() {
+ let pause = RendererInspectorPauseBridge::default();
+ let command = replacement(&pause).begin().unwrap();
+ let handle = Arc::clone(&command);
+ drop(command);
+ assert_replacement_exit(&pause);
+ drop(handle);
+ assert_debugging_enabled(&pause);
+}
+
+#[test]
+fn overlapping_preparations_cannot_finish_each_others_scope() {
+ for finish_first in [true, false] {
+ let pause = RendererInspectorPauseBridge::default();
+ let first = replacement(&pause).begin().unwrap();
+ let second = replacement(&pause).begin().unwrap();
+ let (finished, pending) = if finish_first {
+ (first, second)
+ } else {
+ (second, first)
+ };
+ drop(finished);
+ assert_replacement_exit(&pause);
+ drop(pending);
+ assert_debugging_enabled(&pause);
+ }
+}
+
+#[test]
+fn replacement_is_document_local() {
+ let first = RendererInspectorPauseBridge::default();
+ let second = RendererInspectorPauseBridge::default();
+ let scope = replacement(&first).begin().unwrap();
+ assert_replacement_exit(&first);
+ assert_debugging_enabled(&second);
+ drop(scope);
+ assert_debugging_enabled(&first);
+}
+
+#[test]
+fn observed_exit_reason_survives_the_end_of_replacement() {
+ let pause = RendererInspectorPauseBridge::default();
+ let scope = replacement(&pause).begin().unwrap();
+ let reason = pause.wait_for_pause_work(|| Some(42));
+ drop(scope);
+ assert_eq!(
+ reason,
+ Err(RendererInspectorPauseExitReason::DocumentReplacement)
+ );
+ assert_debugging_enabled(&pause);
+}
+
+#[test]
+fn target_closure_takes_precedence_and_prevents_new_replacement() {
+ let pause = RendererInspectorPauseBridge::default();
+ let scope = replacement(&pause).begin().unwrap();
+ pause.close_target();
+ assert!(replacement(&pause).begin().is_err());
+ drop(scope);
+ assert_eq!(
+ pause.wait_for_pause_work(|| Some(42)),
+ Err(RendererInspectorPauseExitReason::TargetClosed)
+ );
+}
+
+#[test]
+fn preparation_wakes_the_pause_loop_and_covers_repeated_pauses() {
+ let pause = RendererInspectorPauseBridge::default();
+ let waiter_pause = pause.clone();
+ 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(waiter_pause.wait_for_pause_work(|| {
+ if let Some(tx) = waiting_tx.take() {
+ tx.send(()).unwrap();
+ }
+ None::<()>
+ }))
+ .unwrap();
+ });
+ let waiting = waiting_rx.recv_timeout(std::time::Duration::from_secs(30));
+ let scope = replacement(&pause).begin().unwrap();
+ let exited = exited_rx.recv_timeout(std::time::Duration::from_secs(30));
+ if exited.is_err() {
+ pause.close_target();
+ }
+ waiter.join().unwrap();
+ waiting.expect("waiter must reach the pause loop before document preparation");
+ assert_eq!(
+ exited.expect("document preparation must wake the pause loop"),
+ Err(RendererInspectorPauseExitReason::DocumentReplacement)
+ );
+ assert_replacement_exit(&pause);
+ assert_replacement_exit(&pause);
+ drop(scope);
+ assert_debugging_enabled(&pause);
+}
+
+async fn prepare(
+ runtime: &crate::JsRuntime,
+ reservation: crate::RendererPageReservationToken,
+ replacement: Option<RendererDocumentReplacement>,
+) -> anyhow::Result<crate::PreparedRendererDocument> {
+ let loader = crate::network::ResourceRequestClient::new(&moli_fetch::FetchConfig::default())?;
+ let url = url::Url::parse("https://replacement.test/").unwrap();
+ tokio::time::timeout(
+ std::time::Duration::from_secs(30),
+ runtime.prepare_streaming_raw_document_from_external_body(
+ reservation,
+ replacement,
+ url.clone(),
+ url,
+ None,
+ false,
+ 0,
+ Vec::new(),
+ 200,
+ vec![("content-type".to_owned(), b"text/html".to_vec())],
+ &loader,
+ crate::RendererWebStorageHandles::ephemeral(),
+ crate::ExternalRawDocumentBodyStream::from_bytes(
+ b"<!doctype html><title>new</title>".to_vec(),
+ ),
+ false,
+ crate::PageVmInitStage::Load,
+ crate::RendererReplyBoundary::Stage,
+ crate::RendererTopLevelNavigationDispatch::FollowInStandaloneAdapter,
+ crate::RendererNavigationReplyPolicy::FollowBeforeReply,
+ None,
+ None,
+ crate::RendererDocumentOptions::default(),
+ ),
+ )
+ .await?
+}
+
+async fn owner_barrier(runtime: &crate::JsRuntime) {
+ let pending = runtime.enqueue_owner_command_probe_for_testing().unwrap();
+ tokio::time::timeout(std::time::Duration::from_secs(30), pending)
+ .await
+ .unwrap()
+ .unwrap()
+ .unwrap();
+}
+
+#[tokio::test]
+async fn renderer_prepare_keeps_scope_until_cancel_or_commit() {
+ let runtime = crate::JsRuntime::initialize();
+ let pause = RendererInspectorPauseBridge::default();
+ for commit in [false, true] {
+ let input = replacement(&pause);
+ let prepared = prepare(
+ &runtime,
+ runtime.reserve_page_for_creation(),
+ Some(input.clone()),
+ )
+ .await
+ .unwrap();
+ assert_replacement_exit(&pause);
+ if commit {
+ let permit = prepared.issue_commit_permit();
+ let (mut page, _, _, _, _) = prepared.commit(permit).await.unwrap();
+ page.close_async().await.unwrap();
+ } else {
+ prepared.cancel().await.unwrap();
+ }
+ assert_debugging_enabled(&pause);
+ drop(input);
+ }
+}
+
+#[tokio::test]
+async fn canceled_replacement_is_rejected_before_renderer_admission() {
+ let runtime = crate::JsRuntime::initialize();
+ let (output_tx, mut output_rx) = crate::runtime::renderer_output_transport_channel();
+ runtime.set_renderer_output_transport_sender(output_tx);
+ let reservation = runtime.reserve_page_for_creation();
+ let pause = RendererInspectorPauseBridge::default();
+ let input = replacement(&pause);
+ input.cancellation.cancel();
+ let result = prepare(&runtime, reservation, Some(input)).await;
+ assert!(
+ matches!(result, Err(error) if error.to_string() == moli_fetch::NET_ERR_ABORTED_ERROR_TEXT)
+ );
+ assert_debugging_enabled(&pause);
+ assert!(matches!(
+ output_rx.try_recv(),
+ Ok(crate::runtime::RendererOutputTransportMessage::PageReservationReleased {
+ owner_local_host_id, page_id,
+ }) if owner_local_host_id == reservation.local_host_id() && page_id == reservation.page_id()
+ ));
+ assert!(matches!(
+ output_rx.try_recv(),
+ Err(tokio::sync::mpsc::error::TryRecvError::Empty)
+ ));
+ assert_eq!(
+ runtime
+ .document_isolate_accounting_for_diagnostics()
+ .created,
+ 0
+ );
+}
+
+#[tokio::test]
+async fn failed_renderer_prepare_releases_scope() {
+ let runtime = crate::JsRuntime::initialize();
+ let other_runtime = crate::JsRuntime::initialize();
+ let pause = RendererInspectorPauseBridge::default();
+ let result = prepare(
+ &runtime,
+ other_runtime.reserve_page_for_creation(),
+ Some(replacement(&pause)),
+ )
+ .await;
+ assert!(
+ result.is_err(),
+ "another owner's reservation must be rejected"
+ );
+ assert_debugging_enabled(&pause);
+}
+
+#[tokio::test]
+async fn rejected_renderer_command_releases_scope() {
+ let runtime = crate::JsRuntime::initialize();
+ let pause = RendererInspectorPauseBridge::default();
+ runtime.close_owner_command_admission_for_testing();
+ assert!(
+ prepare(
+ &runtime,
+ runtime.reserve_page_for_creation(),
+ Some(replacement(&pause))
+ )
+ .await
+ .is_err()
+ );
+ assert_debugging_enabled(&pause);
+}
+
+#[tokio::test]
+async fn dropping_prepared_handle_retires_owner_scope() {
+ let runtime = crate::JsRuntime::initialize();
+ let pause = RendererInspectorPauseBridge::default();
+ let prepared = prepare(
+ &runtime,
+ runtime.reserve_page_for_creation(),
+ Some(replacement(&pause)),
+ )
+ .await
+ .unwrap();
+ assert_replacement_exit(&pause);
+ drop(prepared);
+ owner_barrier(&runtime).await;
+ assert_debugging_enabled(&pause);
+ assert_eq!(
+ runtime
+ .document_isolate_accounting_for_diagnostics()
+ .reserved,
+ 0
+ );
+}
+
+#[tokio::test]
+async fn dropping_inflight_prepare_retires_queued_document_and_scope() {
+ let runtime = crate::JsRuntime::initialize();
+ let pause = RendererInspectorPauseBridge::default();
+ let (entered, release) = runtime.install_owner_command_dispatch_gate_for_testing();
+ let mut pending = Box::pin(prepare(
+ &runtime,
+ runtime.reserve_page_for_creation(),
+ Some(replacement(&pause)),
+ ));
+ assert!(futures_util::poll!(&mut pending).is_pending());
+ let reached_gate = entered.recv_timeout(std::time::Duration::from_secs(30));
+ assert_replacement_exit(&pause);
+ drop(pending);
+ // The queued command still owns the scope until owner-side cancellation.
+ assert_replacement_exit(&pause);
+ let released = release.send(());
+ reached_gate.unwrap();
+ released.unwrap();
+ owner_barrier(&runtime).await;
+ assert_debugging_enabled(&pause);
+ assert_eq!(
+ runtime
+ .document_isolate_accounting_for_diagnostics()
+ .reserved,
+ 0
+ );
+}
diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rs
index c22ab7d22..7d823993c 100644
--- a/moli-renderer-v8/src/runtime/mod.rs
+++ b/moli-renderer-v8/src/runtime/mod.rs
@@ -44,6 +44,7 @@ mod access;
mod browser_context_runtime;
mod document_lifecycle;
mod document_lifecycle_turn;
+mod document_replacement;
mod javascript_dialog;
mod lifecycle_decision;
mod main_document_ready_gate;
@@ -54,6 +55,7 @@ mod owner_deadline_index;
mod owner_local;
mod owner_local_store;
mod owner_maintenance;
+pub use document_replacement::RendererDocumentReplacement;
mod page;
mod page_commands;
mod page_context_cancel;
@@ -434,7 +436,6 @@ 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.rs b/moli-renderer-v8/src/runtime/owner.rs
index fd9f90f1f..62ceeddec 100644
--- a/moli-renderer-v8/src/runtime/owner.rs
+++ b/moli-renderer-v8/src/runtime/owner.rs
@@ -185,6 +185,8 @@ pub struct RendererCreateHtmlPageRequest {
}
pub struct RendererCreateStreamingRawPageRequest {
+ pub(super) document_replacement:
+ Option<Arc<super::document_replacement::RendererDocumentReplacementScope>>,
pub root_frame_id: Option<String>,
pub main_document_commit: Option<RendererMainDocumentCommit>,
pub requested_url: Url,
diff --git a/moli-renderer-v8/src/runtime/owner/owner_commands.rs b/moli-renderer-v8/src/runtime/owner/owner_commands.rs
index cb202525c..37cf32112 100644
--- a/moli-renderer-v8/src/runtime/owner/owner_commands.rs
+++ b/moli-renderer-v8/src/runtime/owner/owner_commands.rs
@@ -177,7 +177,7 @@ impl RendererOwnerHandle {
/// observes `Opened` before this release on success, while an early failure
/// produces only the release. Never move this to the navigation completion
/// channel: that independent channel cannot order against stream opening.
- pub(super) fn release_page_output_reservation(
+ pub(in crate::runtime) fn release_page_output_reservation(
&self,
reservation: RendererPageReservationToken,
) {
diff --git a/moli-renderer-v8/src/runtime/owner/page_creation.rs b/moli-renderer-v8/src/runtime/owner/page_creation.rs
index 4bab8b073..312572622 100644
--- a/moli-renderer-v8/src/runtime/owner/page_creation.rs
+++ b/moli-renderer-v8/src/runtime/owner/page_creation.rs
@@ -722,6 +722,7 @@ impl RendererOwnerHandle {
options: crate::RendererDocumentOptions,
) -> RendererCreateStreamingRawPageRequest {
RendererCreateStreamingRawPageRequest {
+ document_replacement: None,
root_frame_id: options.root_frame_id,
main_document_commit: options.main_document_commit,
requested_url,
@@ -1108,6 +1109,7 @@ impl RendererOwnerHandle {
_owner_local_store: &mut RendererOwnerLocalStore,
) -> RenderRuntimeDispatchOutcome {
let RendererCreateStreamingRawPageRequest {
+ document_replacement: _document_replacement,
root_frame_id,
main_document_commit,
requested_url,
diff --git a/moli-renderer-v8/src/runtime/owner_local.rs b/moli-renderer-v8/src/runtime/owner_local.rs
index 2a5a590cf..318021e57 100644
--- a/moli-renderer-v8/src/runtime/owner_local.rs
+++ b/moli-renderer-v8/src/runtime/owner_local.rs
@@ -271,9 +271,13 @@ impl RendererPageHandle {
self.devtools_target.pause_ref().is_pause_active()
}
- #[doc(hidden)]
- pub fn renderer_devtools_target(&self) -> super::RendererDevToolsTargetHandle {
- self.devtools_target.clone()
+ /// Captures this exact document without disturbing its execution. Only a
+ /// renderer prepare operation may activate the replacement.
+ pub fn document_replacement(
+ &self,
+ cancellation: moli_fetch::FetchCancelHandle,
+ ) -> super::RendererDocumentReplacement {
+ super::RendererDocumentReplacement::new(self.devtools_target.pause(), cancellation)
}
/// Enqueues the DevTools IO-agent script policy without borrowing the
diff --git a/moli-renderer-v8/src/runtime/page.rs b/moli-renderer-v8/src/runtime/page.rs
index 435ebce44..bcb693307 100644
--- a/moli-renderer-v8/src/runtime/page.rs
+++ b/moli-renderer-v8/src/runtime/page.rs
@@ -472,6 +472,7 @@ impl JsRuntime {
let prepared = self
.prepare_streaming_raw_document_from_external_body(
self.reserve_page_for_creation(),
+ None,
requested_url,
final_url,
navigation_initiator_url,
@@ -503,6 +504,7 @@ impl JsRuntime {
pub async fn prepare_streaming_raw_document_from_external_body(
&self,
page_reservation: RendererPageReservationToken,
+ replacement: Option<super::RendererDocumentReplacement>,
requested_url: Url,
final_url: Url,
navigation_initiator_url: Option<Url>,
@@ -547,6 +549,26 @@ impl JsRuntime {
request.navigation_reply_policy = navigation_reply_policy;
request.reserved_service_worker_client = reserved_service_worker_client;
request.lifecycle_decider = lifecycle_decider;
+ // This is the provisional-load boundary. Wake the old document before
+ // dispatching owner work: queuing the wake itself would deadlock behind
+ // a paused script. Downloads and intercepted responses never get here.
+ let replacement = replacement
+ .map(super::RendererDocumentReplacement::begin)
+ .transpose()
+ .inspect_err(|_| {
+ self.inner
+ .renderer_owner
+ .release_page_output_reservation(page_reservation);
+ })?;
+ request.document_replacement = replacement.clone();
+ // Own cancellation before awaiting the prepare reply, so abandoning
+ // the future also retires a queued or already stored preparation.
+ let preparation = RendererDocumentPreparation {
+ runtime: self.clone(),
+ token: page_reservation,
+ cancel_on_drop: true,
+ _document_replacement: replacement,
+ };
let reply = self
.inner
.renderer_owner
@@ -558,11 +580,10 @@ impl JsRuntime {
match reply {
RendererOwnerReply::PreparedRendererDocumentStored {
renderer_devtools_agent_token,
- } => Ok(PreparedRendererDocument::new(
- self.clone(),
- page_reservation,
+ } => Ok(PreparedRendererDocument {
+ preparation,
renderer_devtools_agent_token,
- )),
+ }),
_ => Err(anyhow!(
"renderer owner returned non-prepare reply for prepared document request"
)),
@@ -608,28 +629,21 @@ impl Drop for JsRuntimeOwner {
/// Dropping this handle schedules cancellation. Only a permit issued for this
/// exact handle can consume the owner-local residence and start bootstrap.
pub struct PreparedRendererDocument {
+ preparation: RendererDocumentPreparation,
+ renderer_devtools_agent_token: super::RendererDevToolsAgentToken,
+}
+
+struct RendererDocumentPreparation {
runtime: JsRuntime,
token: RendererPageReservationToken,
- renderer_devtools_agent_token: super::RendererDevToolsAgentToken,
cancel_on_drop: bool,
+ _document_replacement:
+ Option<Arc<super::document_replacement::RendererDocumentReplacementScope>>,
}
impl PreparedRendererDocument {
- fn new(
- runtime: JsRuntime,
- token: RendererPageReservationToken,
- renderer_devtools_agent_token: super::RendererDevToolsAgentToken,
- ) -> Self {
- Self {
- runtime,
- token,
- renderer_devtools_agent_token,
- cancel_on_drop: true,
- }
- }
-
pub fn token(&self) -> RendererPageReservationToken {
- self.token
+ self.preparation.token
}
pub fn renderer_devtools_agent_token(&self) -> super::RendererDevToolsAgentToken {
@@ -637,7 +651,7 @@ impl PreparedRendererDocument {
}
pub fn issue_commit_permit(&self) -> RendererDocumentCommitPermit {
- RendererDocumentCommitPermit::new(self.token)
+ RendererDocumentCommitPermit::new(self.token())
}
/// Replaces the live target configuration consumed when the first
@@ -647,12 +661,13 @@ impl PreparedRendererDocument {
configuration: super::RendererPreparedDocumentCommitConfiguration,
) -> Result<()> {
let reply = self
+ .preparation
.runtime
.inner
.renderer_owner
.dispatch_command(
RendererOwnerCommand::UpdatePreparedRendererDocumentCommitConfiguration {
- token: self.token,
+ token: self.token(),
configuration,
},
)
@@ -676,17 +691,19 @@ impl PreparedRendererDocument {
Option<RendererPendingDownloadActivation>,
)> {
anyhow::ensure!(
- permit.prepared_document() == self.token,
+ permit.prepared_document() == self.token(),
"renderer document commit permit does not belong to this prepared document"
);
- self.cancel_on_drop = false;
let reply = self
+ .preparation
.runtime
.inner
.renderer_owner
.dispatch_command(RendererOwnerCommand::CommitPreparedRendererDocument { permit })
.await?;
- self.runtime
+ self.preparation.cancel_on_drop = false;
+ self.preparation
+ .runtime
.inner
.renderer_owner
.materialize_page_created_reply_parts(reply)
@@ -694,16 +711,17 @@ impl PreparedRendererDocument {
pub async fn cancel(mut self) -> Result<()> {
let reply = self
+ .preparation
.runtime
.inner
.renderer_owner
.dispatch_command(RendererOwnerCommand::CancelPreparedRendererDocument {
- token: self.token,
+ token: self.token(),
})
.await?;
match reply {
RendererOwnerReply::PreparedRendererDocumentCanceled => {
- self.cancel_on_drop = false;
+ self.preparation.cancel_on_drop = false;
Ok(())
}
_ => Err(anyhow!(
@@ -713,7 +731,7 @@ impl PreparedRendererDocument {
}
}
-impl Drop for PreparedRendererDocument {
+impl Drop for RendererDocumentPreparation {
fn drop(&mut self) {
if !self.cancel_on_drop {
return;
diff --git a/moli-renderer-v8/src/runtime/tests.rs b/moli-renderer-v8/src/runtime/tests.rs
index be24102fb..33fd865a8 100644
--- a/moli-renderer-v8/src/runtime/tests.rs
+++ b/moli-renderer-v8/src/runtime/tests.rs
@@ -68,6 +68,7 @@ async fn prepare_test_external_raw_document_with_content_type_and_reply_boundary
runtime
.prepare_streaming_raw_document_from_external_body(
runtime.reserve_page_for_creation(),
+ None,
url.clone(),
url,
None,
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 e0267d796..ee244ba96 100644
--- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs
@@ -239,11 +239,13 @@ impl RendererInspectorSessionExecutorLocal {
}
}
};
- if exit_reason == crate::devtools::pause::RendererInspectorPauseExitReason::Navigation {
+ if exit_reason
+ == crate::devtools::pause::RendererInspectorPauseExitReason::DocumentReplacement
+ {
// 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
+ // Later pauses observe the same renderer preparation scope until
+ // it commits or is discarded. No debugger setting leaks
// into the replacement document's Inspector restore snapshots.
let sessions: Vec<_> = self
.sessions