Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor: replace page generations with attachment identities

ldm07ab11db7569e
diff --git a/moli-protocol/src/conn/bidi_channel_work.rs b/moli-protocol/src/conn/bidi_channel_work.rs
index fedbc0a8b..1ac09e83a 100644
--- a/moli-protocol/src/conn/bidi_channel_work.rs
+++ b/moli-protocol/src/conn/bidi_channel_work.rs
@@ -22,7 +22,7 @@ impl BidiChannelPageOwner {
///
/// Callers using the implicit `None` session must invoke this while the
/// target's owner-route override is installed. `owner_scope` freezes that
- /// route, while `attachment` freezes the target Page generation and exact
+ /// route, while `attachment` freezes the target Page residence and exact
/// protocol session.
pub(crate) fn capture(conn: &CdpConnection, session_id: Option<&str>) -> Option<Self> {
Some(Self {
@@ -173,20 +173,22 @@ mod tests {
browser_context.set_active_target_id("TID-owner");
browser_context.attach_active_session("SID-owner".to_owned());
conn.browser_context = Some(browser_context);
+ conn.runtime_session_owner_slot_mut(Some("SID-owner"))
+ .expect("test runtime slot")
+ .set_page_attachment_id_for_test(1);
conn
}
#[test]
- fn page_owner_rejects_replacement_generation() {
+ fn page_owner_rejects_replacement_attachment() {
let mut conn = connection_with_page_session();
let owner =
BidiChannelPageOwner::capture(&conn, Some("SID-owner")).expect("test Page attachment");
assert!(owner.is_current(&conn));
- let next_generation = owner.attachment.page_owner().loaded_page_generation() + 1;
conn.runtime_session_owner_slot_mut(Some("SID-owner"))
.expect("test runtime slot")
- .set_loaded_page_generation(next_generation);
+ .replace_page_attachment_id_for_test();
assert!(
!owner.is_current(&conn),
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 8617dc5e4..7b88f8591 100644
--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs
+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs
@@ -2259,14 +2259,17 @@ impl<'a> TargetSessionOwnerMut<'a> {
} => {
let committed_document_post_response_continuation =
page.take_committed_document_post_response_continuation();
- let previous_page_owner = TargetPageResidenceIdentity::new(
- browser_context.id.clone(),
- Some(target_id.clone()),
- browser_context
- .background_target(target_id)?
- .runtime_slot
- .loaded_page_generation(),
- );
+ let previous_page_owner = browser_context
+ .background_target(target_id)?
+ .runtime_slot
+ .page_attachment_id()
+ .map(|page_attachment_id| {
+ TargetPageResidenceIdentity::new(
+ browser_context.id.clone(),
+ Some(target_id.clone()),
+ page_attachment_id,
+ )
+ });
let primary_session_id = browser_context
.background_target(target_id)?
.session_id()
@@ -2357,7 +2360,7 @@ impl<'a> TargetSessionOwnerMut<'a> {
target.runtime_slot.clear_websocket_artifacts();
previous
};
- let replaced_page_owner = previous.as_ref().map(|_| previous_page_owner);
+ let replaced_page_owner = previous.as_ref().and(previous_page_owner);
if let Some(page) = previous {
let _ = page.close_async().await;
}
@@ -2973,44 +2976,79 @@ impl CdpConnection {
// identity must never retain that mutable shorthand. Freeze the
// concrete target now, otherwise a later `browsingContext.create`
// can make output from the old Page resolve through the new active
- // target while preserving the same browser-context id and generation.
+ // target while preserving the same browser-context id and residence.
let target_id = routed_target_id.or_else(|| {
self.browser_context_by_id(&browser_context_id)
.and_then(|browser_context| browser_context.active_target_id())
.map(str::to_owned)
});
- let loaded_page_generation = self
+ let page_attachment_id = self
.runtime_session_owner_slot(session_id)
.ok()?
- .loaded_page_generation();
+ .page_residence_id();
Some(TargetPageResidenceIdentity::new(
browser_context_id,
target_id,
- loaded_page_generation,
+ page_attachment_id,
))
}
- /// Captures the residence that the next successfully installed Page will
- /// occupy for `session_id`.
+ /// Captures the reserved residence of the Page currently being built for
+ /// `session_id`.
///
/// Renderer construction can open and publish into its output stream
/// before protocol commits that Page into the target slot. The reservation
- /// must therefore bind to the generation produced by the pending install,
- /// not the generation of the Page currently occupying the slot.
- pub(crate) fn next_target_page_residence_identity_for_session(
+ /// therefore owns an explicit attachment id before renderer work starts;
+ /// callers never predict that identity from mutable current-Page state.
+ pub(crate) fn pending_target_page_residence_identity_for_session(
&self,
session_id: Option<&str>,
) -> Option<TargetPageResidenceIdentity> {
- let current = self.target_page_residence_identity_for_session(session_id)?;
+ let (browser_context_id, routed_target_id) =
+ self.target_owner_identity_for_session(session_id)?;
+ let target_id = routed_target_id.or_else(|| {
+ self.browser_context_by_id(&browser_context_id)
+ .and_then(|browser_context| browser_context.active_target_id())
+ .map(str::to_owned)
+ });
+ let page_attachment_id = self
+ .runtime_session_owner_slot(session_id)
+ .ok()?
+ .pending_page_attachment_id()?;
+ Some(TargetPageResidenceIdentity::new(
+ browser_context_id,
+ target_id,
+ page_attachment_id,
+ ))
+ }
+
+ /// Binds a renderer Page reservation to its explicit future target Page
+ /// attachment and returns that exact residence identity.
+ pub(crate) fn reserve_target_page_residence_identity_for_session(
+ &mut self,
+ session_id: Option<&str>,
+ renderer_page: crate::conn::RendererPageResidenceIdentity,
+ ) -> Option<TargetPageResidenceIdentity> {
+ let (browser_context_id, routed_target_id) =
+ self.target_owner_identity_for_session(session_id)?;
+ let target_id = routed_target_id.or_else(|| {
+ self.browser_context_by_id(&browser_context_id)
+ .and_then(|browser_context| browser_context.active_target_id())
+ .map(str::to_owned)
+ });
+ let page_attachment_id = self
+ .runtime_session_owner_slot_mut(session_id)
+ .ok()?
+ .reserve_renderer_page_attachment(renderer_page);
Some(TargetPageResidenceIdentity::new(
- current.browser_context_id().to_owned(),
- current.target_id().map(str::to_owned),
- current.loaded_page_generation().wrapping_add(1),
+ browser_context_id,
+ target_id,
+ page_attachment_id,
))
}
/// Checks that deferred Page-owned work still addresses the same target
- /// and installed Page generation from which it was captured.
+ /// Page-slot residence from which it was captured.
pub(crate) fn target_page_residence_identity_is_current_for_session(
&self,
session_id: Option<&str>,
@@ -3099,7 +3137,7 @@ impl CdpConnection {
Some(attachment)
}
- /// Checks both the target Page generation and the session that originally
+ /// Checks both the target Page residence and the session that originally
/// captured an attachment-sensitive output.
pub(crate) fn target_page_protocol_attachment_identity_is_current(
&self,
@@ -3319,7 +3357,7 @@ impl CdpConnection {
/// event produced for `session_id`'s owner.
///
/// The returned identities freeze both the capture-time session and the
- /// installed Page generation. A deferred output may later authorize these
+ /// Page-slot residence. A deferred output may later authorize these
/// identities, but must never call `page_event_session_ids_for_session_owner`
/// again: doing so could route an old Page's historical event through a
/// replacement Page or a newly active implicit attachment.
@@ -3600,10 +3638,10 @@ mod tests {
fn pending_subresource_fetch(internal_id: u64) -> PendingSubresourceFetchRequest {
PendingSubresourceFetchRequest {
residence: crate::conn::PendingSubresourceFetchResidence::InstalledPage(
- crate::conn::TargetPageResidenceIdentity::new(
+ crate::conn::TargetPageResidenceIdentity::new_for_test(
"BID-target-session-owner".to_owned(),
Some("TID-frame".to_owned()),
- 0,
+ 1,
),
),
owner_session_id: None,
@@ -4527,12 +4565,15 @@ mod tests {
}
#[test]
- fn target_page_residence_identity_rejects_context_target_and_generation_collisions() {
+ fn target_page_residence_identity_rejects_context_target_and_attachment_collisions() {
let mut conn = CdpConnection::default();
let mut browser_context = BrowserContext::new("BID-page-residence".to_owned());
browser_context.set_active_target_id("TID-page-residence");
browser_context.attach_active_session("SID-page-residence");
conn.browser_context = Some(browser_context);
+ conn.runtime_session_owner_slot_mut(Some("SID-page-residence"))
+ .expect("active target runtime slot")
+ .set_page_attachment_id_for_test(41);
let current = conn
.target_page_residence_identity_for_session(Some("SID-page-residence"))
@@ -4546,17 +4587,17 @@ mod tests {
TargetPageResidenceIdentity::new(
"BID-other".to_owned(),
Some("TID-page-residence".to_owned()),
- current.loaded_page_generation(),
+ current.page_attachment_id(),
),
TargetPageResidenceIdentity::new(
"BID-page-residence".to_owned(),
Some("TID-other".to_owned()),
- current.loaded_page_generation(),
+ current.page_attachment_id(),
),
TargetPageResidenceIdentity::new(
"BID-page-residence".to_owned(),
Some("TID-page-residence".to_owned()),
- current.loaded_page_generation() + 1,
+ crate::conn::TargetPageAttachmentId::allocate(),
),
] {
assert!(
@@ -4575,6 +4616,9 @@ mod tests {
let mut browser_context = BrowserContext::new("BID-implicit-page-residence".to_owned());
browser_context.set_active_target_id("TID-original");
conn.browser_context = Some(browser_context);
+ conn.runtime_session_owner_slot_mut(None)
+ .expect("implicit active runtime slot")
+ .set_page_attachment_id_for_test(1);
let original = conn
.target_page_residence_identity_for_session(None)
diff --git a/moli-protocol/src/conn/dispatch_tests.rs b/moli-protocol/src/conn/dispatch_tests.rs
index 554fc4d76..4b4817b93 100644
--- a/moli-protocol/src/conn/dispatch_tests.rs
+++ b/moli-protocol/src/conn/dispatch_tests.rs
@@ -614,17 +614,11 @@ async fn devtools_script_navigation_exact_cursor_rejects_replaced_page_owner_act
let mut route_scope = ctx
.conn
.scoped_none_session_owner_route_override(route.clone());
- let next_generation = route_scope
- .conn_mut()
- .runtime_session_owner_slot(None)
- .expect("created target runtime slot")
- .loaded_page_generation()
- + 1;
route_scope
.conn_mut()
.runtime_session_owner_slot_mut(None)
.expect("created target runtime slot")
- .set_loaded_page_generation(next_generation);
+ .replace_page_attachment_id_for_test();
}
let sent_start = ctx.sent.len();
@@ -2428,7 +2422,7 @@ async fn stale_initial_document_page_build_does_not_overwrite_committed_page() {
&parsed_real_page_url,
)
.expect("real navigation identity should commit");
- let generation_after_real_page = conn
+ let attachment_after_real_page = conn
.browser_context
.as_ref()
.expect("browser context")
@@ -2561,7 +2555,7 @@ async fn stale_initial_document_page_build_does_not_overwrite_committed_page() {
let browser_context = conn.browser_context.as_ref().expect("browser context");
assert_eq!(
browser_context.page_attachment_id(),
- generation_after_real_page,
+ attachment_after_real_page,
"discarding stale initial document build must not replace the current page"
);
assert_eq!(
diff --git a/moli-protocol/src/conn/inspector_route.rs b/moli-protocol/src/conn/inspector_route.rs
index 8f5f005e8..7d7369830 100644
--- a/moli-protocol/src/conn/inspector_route.rs
+++ b/moli-protocol/src/conn/inspector_route.rs
@@ -158,7 +158,7 @@ impl CdpConnection {
.commit_renderer_agent_candidate_transaction(candidate, renderer_page)
.map_err(|error| error.to_string())?;
let page_owner = self
- .next_target_page_residence_identity_for_session(session_id)
+ .pending_target_page_residence_identity_for_session(session_id)
.ok_or_else(|| "NavigationTargetOwnerMissing".to_owned())?;
self.bind_renderer_page_output_owner(renderer_page, page_owner);
Ok(transaction)
diff --git a/moli-protocol/src/conn/page_state/fetch_state.rs b/moli-protocol/src/conn/page_state/fetch_state.rs
index 9d6c60fc1..227eb9b69 100644
--- a/moli-protocol/src/conn/page_state/fetch_state.rs
+++ b/moli-protocol/src/conn/page_state/fetch_state.rs
@@ -369,10 +369,10 @@ mod tests {
fn pending_subresource_fetch(internal_id: u64) -> PendingSubresourceFetchRequest {
PendingSubresourceFetchRequest {
residence: crate::conn::PendingSubresourceFetchResidence::InstalledPage(
- crate::conn::TargetPageResidenceIdentity::new(
+ crate::conn::TargetPageResidenceIdentity::new_for_test(
"BID-fetch-state".to_owned(),
Some("TID-1".to_owned()),
- 0,
+ 1,
),
),
owner_session_id: None,
diff --git a/moli-protocol/src/conn/page_state/loaded.rs b/moli-protocol/src/conn/page_state/loaded.rs
index c7e04cc65..4a6703e75 100644
--- a/moli-protocol/src/conn/page_state/loaded.rs
+++ b/moli-protocol/src/conn/page_state/loaded.rs
@@ -250,11 +250,17 @@ impl BrowserContext {
) -> anyhow::Result<LoadedNavigationPageCommit> {
let committed_document_post_response_continuation =
page.take_committed_document_post_response_continuation();
- let previous_page_owner = TargetPageResidenceIdentity::new(
- self.id.clone(),
- self.active_target_id_owned(),
- self.active_target.runtime_slot.loaded_page_generation(),
- );
+ let previous_page_owner =
+ self.active_target
+ .runtime_slot
+ .page_attachment_id()
+ .map(|page_attachment_id| {
+ TargetPageResidenceIdentity::new(
+ self.id.clone(),
+ self.active_target_id_owned(),
+ page_attachment_id,
+ )
+ });
let primary_session_id = self.active_session_id_owned();
let previous_attachment = match renderer_attachment_commit {
LoadedNavigationRendererAttachmentCommit::Prepare(renderer_agent_candidate) => self
@@ -300,7 +306,7 @@ impl BrowserContext {
.owner_state
.commit_document_title(committed_document_title);
self.clear_active_target_runtime_remote_object_tracking();
- let replaced_page_owner = previous.as_ref().map(|_| previous_page_owner);
+ let replaced_page_owner = previous.as_ref().and(previous_page_owner);
if let Some(page) = previous {
Self::close_page_best_effort(page).await;
}
diff --git a/moli-protocol/src/conn/page_state/parked.rs b/moli-protocol/src/conn/page_state/parked.rs
index f250cc783..2dc429fe0 100644
--- a/moli-protocol/src/conn/page_state/parked.rs
+++ b/moli-protocol/src/conn/page_state/parked.rs
@@ -1578,19 +1578,19 @@ impl BrowserContext {
if expected.browser_context_id() != self.id {
return false;
}
- let current_generation = match expected.target_id() {
+ let current_residence = match expected.target_id() {
Some(target_id) if self.is_active_target(target_id) => {
- Some(self.active_target.runtime_slot.loaded_page_generation())
+ Some(self.active_target.runtime_slot.page_residence_id())
}
Some(target_id) => self
.background_target(target_id)
- .map(|target| target.runtime_slot.loaded_page_generation()),
+ .map(|target| target.runtime_slot.page_residence_id()),
None if self.active_target_id().is_none() => {
- Some(self.active_target.runtime_slot.loaded_page_generation())
+ Some(self.active_target.runtime_slot.page_residence_id())
}
None => None,
};
- current_generation == Some(expected.loaded_page_generation())
+ current_residence == Some(expected.page_attachment_id())
}
pub(crate) fn dedicated_worker_target_id_for_renderer_instance(
diff --git a/moli-protocol/src/conn/runtime_eval.rs b/moli-protocol/src/conn/runtime_eval.rs
index 29648a2a1..7e29bf844 100644
--- a/moli-protocol/src/conn/runtime_eval.rs
+++ b/moli-protocol/src/conn/runtime_eval.rs
@@ -6660,13 +6660,9 @@ mod tests {
conn.publish_bidi_channel_listener_start(listener);
let held_listener_work = take_only_protocol_work(&mut conn);
- let current_generation = conn
- .runtime_session_owner_slot(Some("SID-active"))
- .expect("test runtime slot")
- .loaded_page_generation();
conn.runtime_session_owner_slot_mut(Some("SID-active"))
.expect("test runtime slot")
- .set_loaded_page_generation(current_generation + 1);
+ .replace_page_attachment_id_for_test();
let mut direct_events = Vec::new();
let mut claimed_events = Vec::new();
@@ -6794,14 +6790,9 @@ mod tests {
);
let work = take_only_protocol_work(&mut conn);
- let next_generation = conn
- .runtime_session_owner_slot(Some("SID-active"))
- .expect("test runtime slot")
- .loaded_page_generation()
- + 1;
conn.runtime_session_owner_slot_mut(Some("SID-active"))
.expect("test runtime slot")
- .set_loaded_page_generation(next_generation);
+ .replace_page_attachment_id_for_test();
conn.register_runtime_remote_object_ids_for_session_owner_with_group(
Some("SID-active"),
vec!["replacement-object".to_owned()],
@@ -6826,14 +6817,9 @@ mod tests {
let listener = bidi_channel_listener_residence_for_test(&conn, "SID-active", "stale-reply");
conn.register_pending_bidi_channel_listener(9, Some("SID-active"), listener);
- let next_generation = conn
- .runtime_session_owner_slot(Some("SID-active"))
- .expect("test runtime slot")
- .loaded_page_generation()
- + 1;
conn.runtime_session_owner_slot_mut(Some("SID-active"))
.expect("test runtime slot")
- .set_loaded_page_generation(next_generation);
+ .replace_page_attachment_id_for_test();
conn.register_runtime_remote_object_ids_for_session_owner_with_group(
Some("SID-active"),
vec!["replacement-object".to_owned()],
diff --git a/moli-protocol/src/conn/runtime_load.rs b/moli-protocol/src/conn/runtime_load.rs
index 0f7bda984..f9e8fe3a8 100644
--- a/moli-protocol/src/conn/runtime_load.rs
+++ b/moli-protocol/src/conn/runtime_load.rs
@@ -1894,7 +1894,7 @@ impl CdpConnection {
// command; binding after `start_*` would leave a real cross-thread race
// where the concrete FIFO receives its first publication ownerless.
let page_owner = self
- .next_target_page_residence_identity_for_session(session_id)
+ .pending_target_page_residence_identity_for_session(session_id)
.ok_or_else(|| "initial document Page reservation lost its target owner".to_owned())?;
self.bind_renderer_page_output_owner(renderer_page, page_owner);
let pending = engine
@@ -2495,16 +2495,14 @@ impl CdpConnection {
Some(browser_context_id.as_str()),
"navigation Page reservation must bind inside its captured browser context"
);
+ let renderer_page = RendererPageResidenceIdentity::from_parts(
+ page_reservation.local_host_id(),
+ page_reservation.page_id(),
+ );
let page_owner = self
- .next_target_page_residence_identity_for_session(session_id)
+ .reserve_target_page_residence_identity_for_session(session_id, renderer_page)
.expect("navigation Page reservation must retain its target owner");
- self.bind_renderer_page_output_owner(
- RendererPageResidenceIdentity::from_parts(
- page_reservation.local_host_id(),
- page_reservation.page_id(),
- ),
- page_owner,
- );
+ self.bind_renderer_page_output_owner(renderer_page, page_owner);
}
}
diff --git a/moli-protocol/src/conn/state/attachment_identity.rs b/moli-protocol/src/conn/state/attachment_identity.rs
index 464b54511..abb10c549 100644
--- a/moli-protocol/src/conn/state/attachment_identity.rs
+++ b/moli-protocol/src/conn/state/attachment_identity.rs
@@ -6,6 +6,11 @@ use std::{
static NEXT_TARGET_PAGE_ATTACHMENT_ID: AtomicU64 = AtomicU64::new(1);
static NEXT_NAVIGATION_REQUEST_ID: AtomicU64 = AtomicU64::new(1);
+/// Opaque identity for one current or reserved target Page residence.
+///
+/// An empty target slot owns a tombstone identity so output captured before a
+/// Page exists cannot match a later Page or a later empty slot. Once a Page is
+/// attached, this same id also keys its directly terminable residence token.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub(crate) struct TargetPageAttachmentId(NonZeroU64);
diff --git a/moli-protocol/src/conn/state/fetch.rs b/moli-protocol/src/conn/state/fetch.rs
index e28af8dde..b8b37766c 100644
--- a/moli-protocol/src/conn/state/fetch.rs
+++ b/moli-protocol/src/conn/state/fetch.rs
@@ -2237,7 +2237,7 @@ mod tests {
}
fn test_page_owner() -> crate::conn::TargetPageResidenceIdentity {
- crate::conn::TargetPageResidenceIdentity::new(
+ crate::conn::TargetPageResidenceIdentity::new_for_test(
"BID-fetch-state".to_owned(),
Some("TID-fetch-state".to_owned()),
1,
diff --git a/moli-protocol/src/conn/state/identity.rs b/moli-protocol/src/conn/state/identity.rs
index d2d3b31b7..f512ba857 100644
--- a/moli-protocol/src/conn/state/identity.rs
+++ b/moli-protocol/src/conn/state/identity.rs
@@ -1,5 +1,7 @@
use moli_core::{PageId, RendererOutputResidenceIdentity, RendererOwnerLocalHostId, page::Page};
+use super::TargetPageAttachmentId;
+
pub const URL_BASE: &str = "chrome://newtab/";
/// Exact renderer Page residence captured with one deferred-load owner action.
@@ -65,34 +67,52 @@ impl RendererPageResidenceIdentity {
}
}
-/// Identifies one installed renderer Page residence within a protocol target.
+/// Identifies one current or reserved Page-slot residence within a protocol
+/// target.
///
/// This identity deliberately does not include the renderer Document. A
/// `document.open()` replacement keeps the same Page residence, while taking,
-/// replacing, or retiring the Page advances `loaded_page_generation`. Deferred
+/// replacing, or retiring the Page changes `page_attachment_id`. Deferred
/// protocol work that belongs to a Page should therefore use this identity for
/// authorization and may carry a renderer Document identity separately as
-/// causal metadata.
+/// causal metadata. The attachment id is allocated when the Page is reserved,
+/// so work emitted before installation and work emitted after commit retain the
+/// same identity without predicting a numeric generation. An empty slot owns a
+/// distinct tombstone id, which prevents output captured in one absence from
+/// matching a later absence or Page.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct TargetPageResidenceIdentity {
browser_context_id: String,
target_id: Option<String>,
- loaded_page_generation: u64,
+ page_attachment_id: TargetPageAttachmentId,
}
impl TargetPageResidenceIdentity {
pub(crate) fn new(
browser_context_id: String,
target_id: Option<String>,
- loaded_page_generation: u64,
+ page_attachment_id: TargetPageAttachmentId,
) -> Self {
Self {
browser_context_id,
target_id,
- loaded_page_generation,
+ page_attachment_id,
}
}
+ #[cfg(test)]
+ pub(crate) fn new_for_test(
+ browser_context_id: String,
+ target_id: Option<String>,
+ page_attachment_id: u64,
+ ) -> Self {
+ Self::new(
+ browser_context_id,
+ target_id,
+ TargetPageAttachmentId::from_raw_for_test(page_attachment_id),
+ )
+ }
+
pub(crate) fn browser_context_id(&self) -> &str {
&self.browser_context_id
}
@@ -101,15 +121,15 @@ impl TargetPageResidenceIdentity {
self.target_id.as_deref()
}
- pub(crate) fn loaded_page_generation(&self) -> u64 {
- self.loaded_page_generation
+ pub(crate) fn page_attachment_id(&self) -> TargetPageAttachmentId {
+ self.page_attachment_id
}
}
-/// Identifies one protocol attachment to one installed target Page.
+/// Identifies one protocol attachment to one target Page residence.
///
/// A Page residence can be observed by more than one CDP session over its
-/// lifetime. Deferred output must therefore retain both the Page generation
+/// lifetime. Deferred output must therefore retain both the Page attachment
/// and the exact session that captured it. Explicit session ids are allocated
/// monotonically by one `CdpConnection` and are never reused. `None` denotes
/// the connection's implicit Page attachment; the embedded Page identity keeps
diff --git a/moli-protocol/src/conn/state/javascript_dialog.rs b/moli-protocol/src/conn/state/javascript_dialog.rs
index 201a68d0b..bfe66031a 100644
--- a/moli-protocol/src/conn/state/javascript_dialog.rs
+++ b/moli-protocol/src/conn/state/javascript_dialog.rs
@@ -401,7 +401,7 @@ mod tests {
let scope = TargetJavaScriptDialogScope::default();
let prepared = TargetPreparedJavaScriptDialog::capture(
TargetPageProtocolAttachmentIdentity::new(
- TargetPageResidenceIdentity::new(
+ TargetPageResidenceIdentity::new_for_test(
"BID-dialog-drop".to_owned(),
Some("TID-dialog-drop".to_owned()),
1,
diff --git a/moli-protocol/src/conn/state/page_slot.rs b/moli-protocol/src/conn/state/page_slot.rs
index a99a4214b..ca5fad32b 100644
--- a/moli-protocol/src/conn/state/page_slot.rs
+++ b/moli-protocol/src/conn/state/page_slot.rs
@@ -80,6 +80,7 @@ impl Hash for DocumentNavigationToken {
#[derive(Debug)]
pub(crate) struct PendingNavigationRequest {
token: DocumentNavigationToken,
+ page_attachment_id: TargetPageAttachmentId,
cancellation_handles: Vec<moli_fetch::FetchCancelHandle>,
background_completion_pending: bool,
committed: bool,
@@ -89,6 +90,7 @@ impl PendingNavigationRequest {
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,
@@ -309,30 +311,83 @@ impl InitialDocumentPageBuildWaiter {
/// because both builds used the same target/session.
#[derive(Debug, Clone, PartialEq, Eq)]
enum PendingRendererPageBinding {
+ PageBuild {
+ renderer_page: RendererPageResidenceIdentity,
+ page_attachment_id: TargetPageAttachmentId,
+ },
InitialDocumentBuild {
renderer_page: RendererPageResidenceIdentity,
+ page_attachment_id: TargetPageAttachmentId,
},
DocumentNavigation {
navigation: DocumentNavigationToken,
renderer_page: RendererPageResidenceIdentity,
+ page_attachment_id: TargetPageAttachmentId,
},
}
impl PendingRendererPageBinding {
fn renderer_page(&self) -> RendererPageResidenceIdentity {
match self {
- Self::InitialDocumentBuild { renderer_page }
+ Self::PageBuild { renderer_page, .. }
+ | Self::InitialDocumentBuild { renderer_page, .. }
| Self::DocumentNavigation { renderer_page, .. } => *renderer_page,
}
}
+
+ fn page_attachment_id(&self) -> TargetPageAttachmentId {
+ match self {
+ Self::PageBuild {
+ page_attachment_id, ..
+ }
+ | Self::InitialDocumentBuild {
+ page_attachment_id, ..
+ }
+ | Self::DocumentNavigation {
+ page_attachment_id, ..
+ } => *page_attachment_id,
+ }
+ }
+}
+
+/// Current residence of the target's Page slot.
+///
+/// The residence id is always present so output captured while a target has no
+/// installed Page cannot later match a different empty or attached residence.
+/// Only `Attached` exposes a Page attachment id to Page-bound operations such
+/// as Input ACK cleanup and renderer lifecycle routing.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum CurrentTargetPageResidence {
+ Absent(TargetPageAttachmentId),
+ Attached(TargetPageAttachmentId),
+}
+
+impl Default for CurrentTargetPageResidence {
+ fn default() -> Self {
+ Self::Absent(TargetPageAttachmentId::allocate())
+ }
+}
+
+impl CurrentTargetPageResidence {
+ fn id(self) -> TargetPageAttachmentId {
+ match self {
+ Self::Absent(id) | Self::Attached(id) => id,
+ }
+ }
+
+ fn attachment_id(self) -> Option<TargetPageAttachmentId> {
+ match self {
+ Self::Absent(_) => None,
+ Self::Attached(id) => Some(id),
+ }
+ }
}
#[derive(Debug, Default)]
pub(crate) struct TargetPageSlot {
loaded_page: Option<Page>,
loaded_page_absence_reason: TargetPageAbsenceReason,
- page_attachment_id: Option<TargetPageAttachmentId>,
- loaded_page_generation: u64,
+ page_residence: CurrentTargetPageResidence,
page_residence_publisher: Option<TargetPageResidencePublisher>,
pending_navigation_request: Option<PendingNavigationRequest>,
committed_document_navigation: Option<DocumentNavigationToken>,
@@ -366,7 +421,7 @@ impl TargetPageSlot {
pub(crate) fn with_loaded_page_for_test(loaded_page: Page) -> Self {
Self {
loaded_page: Some(loaded_page),
- page_attachment_id: Some(TargetPageAttachmentId::allocate()),
+ page_residence: CurrentTargetPageResidence::Attached(TargetPageAttachmentId::allocate()),
..Default::default()
}
}
@@ -423,8 +478,10 @@ impl TargetPageSlot {
{
return false;
}
- self.pending_renderer_page =
- Some(PendingRendererPageBinding::InitialDocumentBuild { renderer_page });
+ self.pending_renderer_page = Some(PendingRendererPageBinding::InitialDocumentBuild {
+ renderer_page,
+ page_attachment_id: TargetPageAttachmentId::allocate(),
+ });
true
}
@@ -467,14 +524,32 @@ impl TargetPageSlot {
page: Option<Page>,
absence_reason: TargetPageAbsenceReason,
) -> Option<Page> {
+ let next_page_residence = match page.as_ref() {
+ Some(page) => {
+ let renderer_page = RendererPageResidenceIdentity::from_page(page);
+ let attachment_id = match self.pending_renderer_page.as_ref() {
+ Some(binding) => {
+ assert_eq!(
+ binding.renderer_page(),
+ renderer_page,
+ "installed Page must match its explicit renderer Page reservation"
+ );
+ binding.page_attachment_id()
+ }
+ None => TargetPageAttachmentId::allocate(),
+ };
+ CurrentTargetPageResidence::Attached(attachment_id)
+ }
+ None => CurrentTargetPageResidence::Absent(TargetPageAttachmentId::allocate()),
+ };
if self.loaded_page.is_some() || page.is_some() {
- self.advance_loaded_page_generation();
+ self.finish_renderer_document_lifecycle_observers(
+ RendererDocumentLifecycleObservation::Superseded,
+ );
}
- self.pending_renderer_page = None;
if page.is_some() {
self.complete_initial_document_page_build();
self.loaded_page_absence_reason = TargetPageAbsenceReason::NoTarget;
- self.page_attachment_id = Some(TargetPageAttachmentId::allocate());
} else {
if self.loaded_page_absence_reason
== TargetPageAbsenceReason::InitialDocumentPageBuildInProgress
@@ -482,8 +557,9 @@ impl TargetPageSlot {
self.fail_initial_document_page_build("InitialDocumentPageBuildCancelled".into());
}
self.loaded_page_absence_reason = absence_reason;
- self.page_attachment_id = None;
}
+ self.page_residence = next_page_residence;
+ self.pending_renderer_page = None;
let previous = std::mem::replace(&mut self.loaded_page, page);
self.supersede_page_residence();
previous
@@ -499,15 +575,63 @@ impl TargetPageSlot {
}
pub(crate) fn page_attachment_id(&self) -> Option<TargetPageAttachmentId> {
- self.page_attachment_id
+ self.page_residence.attachment_id()
+ }
+
+ pub(crate) fn page_residence_id(&self) -> TargetPageAttachmentId {
+ self.page_residence.id()
+ }
+
+ pub(crate) fn pending_page_attachment_id(&self) -> Option<TargetPageAttachmentId> {
+ self.pending_renderer_page
+ .as_ref()
+ .map(PendingRendererPageBinding::page_attachment_id)
+ .or_else(|| {
+ self.pending_navigation_request
+ .as_ref()
+ .filter(|request| !request.committed)
+ .map(|request| request.page_attachment_id)
+ })
}
- pub(crate) fn loaded_page_generation(&self) -> u64 {
- self.loaded_page_generation
+ pub(crate) fn reserve_renderer_page_attachment(
+ &mut self,
+ renderer_page: RendererPageResidenceIdentity,
+ ) -> TargetPageAttachmentId {
+ if let Some(binding) = self.pending_renderer_page.as_ref() {
+ if binding.renderer_page() == renderer_page {
+ return binding.page_attachment_id();
+ }
+ // A newly reserved renderer Page supersedes an earlier build that
+ // never reached installation. Its old output-owner binding remains
+ // harmless because this slot no longer routes that renderer Page.
+ self.pending_renderer_page = None;
+ }
+
+ if let Some(request) = self
+ .pending_navigation_request
+ .as_ref()
+ .filter(|request| !request.committed)
+ {
+ let page_attachment_id = request.page_attachment_id;
+ self.pending_renderer_page = Some(PendingRendererPageBinding::DocumentNavigation {
+ navigation: request.token.clone(),
+ renderer_page,
+ page_attachment_id,
+ });
+ return page_attachment_id;
+ }
+
+ let page_attachment_id = TargetPageAttachmentId::allocate();
+ self.pending_renderer_page = Some(PendingRendererPageBinding::PageBuild {
+ renderer_page,
+ page_attachment_id,
+ });
+ page_attachment_id
}
pub(crate) fn page_residence_token(&mut self) -> Option<TargetPageResidenceToken> {
- let attachment_id = self.page_attachment_id?;
+ let attachment_id = self.page_attachment_id()?;
let publisher = self
.page_residence_publisher
.get_or_insert_with(|| TargetPageResidencePublisher::new(attachment_id));
@@ -520,38 +644,37 @@ impl TargetPageSlot {
}
}
- fn advance_loaded_page_generation(&mut self) {
- self.finish_renderer_document_lifecycle_observers(
- RendererDocumentLifecycleObservation::Superseded,
- );
- self.loaded_page_generation = self.loaded_page_generation.wrapping_add(1);
- }
-
#[cfg(test)]
- pub(crate) fn bump_loaded_page_generation(&mut self) {
- self.advance_loaded_page_generation();
+ pub(crate) fn set_page_attachment_id_for_test(&mut self, raw: u64) -> TargetPageAttachmentId {
+ let attachment_id = TargetPageAttachmentId::from_raw_for_test(raw);
+ self.install_page_attachment_id_for_test(attachment_id);
+ attachment_id
}
#[cfg(test)]
- pub(crate) fn set_loaded_page_generation(&mut self, generation: u64) {
- if self.loaded_page_generation == generation {
- return;
+ pub(crate) fn replace_page_attachment_id_for_test(&mut self) -> TargetPageAttachmentId {
+ let mut attachment_id = TargetPageAttachmentId::allocate();
+ while self.page_residence.id() == attachment_id {
+ attachment_id = TargetPageAttachmentId::allocate();
}
- self.finish_renderer_document_lifecycle_observers(
- RendererDocumentLifecycleObservation::Superseded,
- );
- self.loaded_page_generation = generation;
+ self.install_page_attachment_id_for_test(attachment_id);
+ attachment_id
}
#[cfg(test)]
- pub(crate) fn set_page_attachment_id_for_test(&mut self, raw: u64) -> TargetPageAttachmentId {
- let attachment_id = TargetPageAttachmentId::from_raw_for_test(raw);
- let attachment_changed = self.page_attachment_id != Some(attachment_id);
- self.page_attachment_id = Some(attachment_id);
+ pub(crate) fn install_page_attachment_id_for_test(
+ &mut self,
+ attachment_id: TargetPageAttachmentId,
+ ) {
+ let attachment_changed = self.page_residence.id() != attachment_id
+ || self.page_residence.attachment_id().is_none();
+ self.page_residence = CurrentTargetPageResidence::Attached(attachment_id);
if attachment_changed {
+ self.finish_renderer_document_lifecycle_observers(
+ RendererDocumentLifecycleObservation::Superseded,
+ );
self.supersede_page_residence();
}
- attachment_id
}
pub(crate) fn start_document_navigation(
@@ -632,13 +755,33 @@ impl TargetPageSlot {
.pending_navigation_request
.as_ref()
.is_some_and(|request| request.matches(token) && !request.committed)
- || self.pending_renderer_page.is_some()
{
return false;
}
+ if let Some(binding) = self.pending_renderer_page.as_ref() {
+ return matches!(
+ binding,
+ PendingRendererPageBinding::DocumentNavigation {
+ navigation,
+ renderer_page: bound_renderer_page,
+ page_attachment_id,
+ } if navigation == token
+ && *bound_renderer_page == renderer_page
+ && Some(*page_attachment_id)
+ == self
+ .pending_navigation_request
+ .as_ref()
+ .map(|request| request.page_attachment_id)
+ );
+ }
self.pending_renderer_page = Some(PendingRendererPageBinding::DocumentNavigation {
navigation: token.clone(),
renderer_page,
+ page_attachment_id: self
+ .pending_navigation_request
+ .as_ref()
+ .expect("validated pending navigation request must remain installed")
+ .page_attachment_id,
});
true
}
@@ -776,7 +919,7 @@ impl TargetPageSlot {
);
return Vec::new();
}
- let Some(page_attachment_id) = self.page_attachment_id else {
+ let Some(page_attachment_id) = self.page_attachment_id() else {
tracing::debug!(
?active_document,
?active_epoch,
@@ -945,7 +1088,7 @@ impl TargetPageSlot {
.binding
.as_ref()
.is_some_and(|binding| {
- Some(binding.page_attachment_id) == self.page_attachment_id
+ Some(binding.page_attachment_id) == self.page_attachment_id()
&& binding.navigation.as_ref().is_none_or(|navigation| {
self.committed_document_navigation.as_ref() == Some(navigation)
})
@@ -1096,7 +1239,7 @@ impl TargetPageSlot {
.binding
.as_ref()
.filter(|binding| {
- Some(binding.page_attachment_id) == self.page_attachment_id
+ Some(binding.page_attachment_id) == self.page_attachment_id()
&& binding.navigation.as_ref().is_none_or(|navigation| {
self.committed_document_navigation.as_ref() == Some(navigation)
})
@@ -1261,7 +1404,7 @@ impl TargetPageSlot {
.as_ref()
.filter(|binding| {
binding.loader_id == loader_id
- && Some(binding.page_attachment_id) == self.page_attachment_id
+ && Some(binding.page_attachment_id) == self.page_attachment_id()
})
.cloned()
else {
@@ -1368,20 +1511,33 @@ mod page_residence_tests {
use crate::conn::TargetPageResidenceObservation;
#[test]
- fn attachment_token_ignores_generation_and_terminates_on_attachment_replacement() {
+ fn empty_slot_residence_is_stable_until_the_slot_transitions() {
+ let mut slot = TargetPageSlot::default();
+ let initial = slot.page_residence_id();
+
+ assert_eq!(slot.page_residence_id(), initial);
+ assert_eq!(slot.page_attachment_id(), None);
+ assert!(
+ slot.replace_loaded_page_with_reason(None, TargetPageAbsenceReason::TestFixture)
+ .is_none()
+ );
+ assert_ne!(slot.page_residence_id(), initial);
+ assert_eq!(slot.page_attachment_id(), None);
+ }
+
+ #[test]
+ fn attachment_token_terminates_on_attachment_replacement() {
let mut slot = TargetPageSlot::default();
slot.set_page_attachment_id_for_test(91);
let token = slot
.page_residence_token()
.expect("the installed attachment should expose its lifetime token");
- slot.bump_loaded_page_generation();
-
let mut wait = Box::pin(token.wait());
let mut context = Context::from_waker(Waker::noop());
assert!(
matches!(wait.as_mut().poll(&mut context), Poll::Pending),
- "changing only the slot generation must not terminate an attachment token"
+ "a live attachment token must remain pending"
);
slot.set_page_attachment_id_for_test(92);
@@ -1423,6 +1579,33 @@ mod pending_renderer_page_tests {
assert!(!slot.routes_renderer_page(expected));
}
+ #[test]
+ fn navigation_reservation_preallocates_one_exact_page_attachment() {
+ let mut slot = TargetPageSlot::default();
+ let current_residence = slot.page_residence_id();
+ let navigation =
+ slot.start_document_navigation("TID-pending-page".to_owned(), "LOADER-next".to_owned());
+ let reserved_attachment = slot
+ .pending_page_attachment_id()
+ .expect("navigation should reserve its future Page attachment");
+ let reserved_page = renderer_page(8, 20);
+
+ assert_ne!(reserved_attachment, current_residence);
+ assert_eq!(
+ slot.reserve_renderer_page_attachment(reserved_page),
+ reserved_attachment
+ );
+ assert_eq!(
+ slot.reserve_renderer_page_attachment(reserved_page),
+ reserved_attachment,
+ "revisiting the same renderer Page reservation must be idempotent"
+ );
+ assert!(
+ slot.bind_pending_document_navigation_renderer_page(&navigation, reserved_page),
+ "the navigation binding should accept its already-reserved renderer Page"
+ );
+ }
+
#[test]
fn navigation_binding_cannot_follow_a_superseding_navigation() {
let mut slot = TargetPageSlot::default();
@@ -1433,7 +1616,7 @@ mod pending_renderer_page_tests {
assert!(slot.routes_renderer_page(first_page));
assert!(
!slot.bind_pending_document_navigation_renderer_page(&first, renderer_page(8, 23),),
- "one navigation generation cannot replace its bound renderer Page"
+ "one navigation request cannot replace its bound renderer Page"
);
let second = slot
@@ -1482,7 +1665,7 @@ mod renderer_document_lifecycle_tests {
fn page_slot_with_attachment() -> TargetPageSlot {
TargetPageSlot {
- page_attachment_id: Some(TargetPageAttachmentId::allocate()),
+ page_residence: CurrentTargetPageResidence::Attached(TargetPageAttachmentId::allocate()),
..Default::default()
}
}
@@ -1545,7 +1728,8 @@ mod renderer_document_lifecycle_tests {
);
assert!(slot.renderer_document_lifecycle_binding().is_some());
- slot.page_attachment_id = None;
+ slot.page_residence =
+ CurrentTargetPageResidence::Absent(TargetPageAttachmentId::allocate());
assert!(
slot.renderer_document_lifecycle_binding().is_none(),
"a binding from a removed Page attachment must never remain current"
diff --git a/moli-protocol/src/conn/state/runtime_slot.rs b/moli-protocol/src/conn/state/runtime_slot.rs
index c5acda4be..d5ca3a62d 100644
--- a/moli-protocol/src/conn/state/runtime_slot.rs
+++ b/moli-protocol/src/conn/state/runtime_slot.rs
@@ -42,7 +42,7 @@ pub(crate) struct FinishedRendererDocumentNavigation {
#[derive(Debug)]
struct RetiringRendererDocumentOutput {
renderer_page: RendererPageResidenceIdentity,
- loaded_page_generation: u64,
+ page_attachment_id: TargetPageAttachmentId,
binding: CommittedRendererDocumentBinding,
network_agent: RetiringTargetNetworkAgentState,
}
@@ -216,15 +216,15 @@ impl TargetRuntimeSlot {
.map(|(loaded_page, binding)| {
(
RendererPageResidenceIdentity::from_page(loaded_page),
- self.page_slot.loaded_page_generation(),
+ binding.page_attachment_id,
binding.clone(),
)
});
let retiring_document =
- retiring_document.map(|(renderer_page, loaded_page_generation, binding)| {
+ retiring_document.map(|(renderer_page, page_attachment_id, binding)| {
RetiringRendererDocumentOutput {
renderer_page,
- loaded_page_generation,
+ page_attachment_id,
binding,
network_agent: self.network_agent.rotate_document_for_replacement(),
}
@@ -291,27 +291,51 @@ impl TargetRuntimeSlot {
self.page_slot.page_attachment_id()
}
+ pub(crate) fn page_residence_id(&self) -> TargetPageAttachmentId {
+ self.page_slot.page_residence_id()
+ }
+
+ pub(crate) fn pending_page_attachment_id(&self) -> Option<TargetPageAttachmentId> {
+ self.page_slot.pending_page_attachment_id()
+ }
+
+ pub(crate) fn reserve_renderer_page_attachment(
+ &mut self,
+ renderer_page: RendererPageResidenceIdentity,
+ ) -> TargetPageAttachmentId {
+ self.page_slot
+ .reserve_renderer_page_attachment(renderer_page)
+ }
+
#[cfg(test)]
pub(crate) fn set_page_attachment_id_for_test(&mut self, raw: u64) -> TargetPageAttachmentId {
+ let attachment_changed = self
+ .page_slot
+ .page_attachment_id()
+ .map(TargetPageAttachmentId::get)
+ != Some(raw);
+ if attachment_changed {
+ self.javascript_dialog_scope.retire();
+ }
self.page_slot.set_page_attachment_id_for_test(raw)
}
- pub(crate) fn loaded_page_generation(&self) -> u64 {
- self.page_slot.loaded_page_generation()
- }
-
#[cfg(test)]
- pub(crate) fn bump_loaded_page_generation(&mut self) {
+ pub(crate) fn replace_page_attachment_id_for_test(&mut self) -> TargetPageAttachmentId {
self.javascript_dialog_scope.retire();
- self.page_slot.bump_loaded_page_generation();
+ self.page_slot.replace_page_attachment_id_for_test()
}
#[cfg(test)]
- pub(crate) fn set_loaded_page_generation(&mut self, generation: u64) {
- if self.page_slot.loaded_page_generation() != generation {
+ pub(crate) fn install_page_attachment_id_for_test(
+ &mut self,
+ attachment_id: TargetPageAttachmentId,
+ ) {
+ if self.page_slot.page_attachment_id() != Some(attachment_id) {
self.javascript_dialog_scope.retire();
}
- self.page_slot.set_loaded_page_generation(generation);
+ self.page_slot
+ .install_page_attachment_id_for_test(attachment_id);
}
pub(crate) fn javascript_dialog_scope_observer(&self) -> TargetJavaScriptDialogScopeObserver {
@@ -474,20 +498,19 @@ impl TargetRuntimeSlot {
pub(crate) fn routes_current_renderer_page_owner(
&self,
renderer_page: RendererPageResidenceIdentity,
- loaded_page_generation: u64,
+ page_attachment_id: TargetPageAttachmentId,
) -> bool {
- self.page_slot.loaded_page_generation() == loaded_page_generation
+ self.page_slot.page_attachment_id() == Some(page_attachment_id)
&& self.page_slot.routes_renderer_page(renderer_page)
}
pub(crate) fn routes_retiring_renderer_page_owner(
&self,
renderer_page: RendererPageResidenceIdentity,
- loaded_page_generation: u64,
+ page_attachment_id: TargetPageAttachmentId,
) -> bool {
self.retiring_renderer_document_outputs.iter().any(|entry| {
- entry.renderer_page == renderer_page
- && entry.loaded_page_generation == loaded_page_generation
+ entry.renderer_page == renderer_page && entry.page_attachment_id == page_attachment_id
})
}
@@ -1462,7 +1485,7 @@ mod tests {
moli_core::RendererOwnerLocalHostId::new_for_testing(3),
page_id,
),
- loaded_page_generation: 1,
+ page_attachment_id: TargetPageAttachmentId::from_raw_for_test(1),
binding: CommittedRendererDocumentBinding {
renderer_frame: RendererFrameToken { page_id },
renderer_document: RendererDocumentToken {
diff --git a/moli-protocol/src/conn/tests/mod.rs b/moli-protocol/src/conn/tests/mod.rs
index b1824b5bd..5e7d3762e 100644
--- a/moli-protocol/src/conn/tests/mod.rs
+++ b/moli-protocol/src/conn/tests/mod.rs
@@ -510,9 +510,9 @@ async fn memory_diagnostics_reports_page_vm_document_isolate_model() {
}
#[tokio::test]
-async fn replacing_or_retiring_a_loaded_page_advances_its_residence_generation() {
+async fn replacing_or_retiring_a_loaded_page_changes_its_attachment_identity() {
let mut conn = CdpConnection::new();
- conn.browser_context = Some(BrowserContext::new("BID-page-generation".to_owned()));
+ conn.browser_context = Some(BrowserContext::new("BID-page-attachment".to_owned()));
let first_page = conn
.load_page_via_runtime_async("data:text/html,<body>first</body>")
.await
@@ -522,25 +522,35 @@ async fn replacing_or_retiring_a_loaded_page_advances_its_residence_generation()
.await
.expect("second Page");
let context = conn.browser_context.as_mut().unwrap();
- let initial_generation = context.active_target.runtime_slot.loaded_page_generation();
+ assert_eq!(
+ context.active_target.runtime_slot.page_attachment_id(),
+ None
+ );
assert!(context.replace_loaded_page(Some(first_page)).is_none());
- let first_generation = context.active_target.runtime_slot.loaded_page_generation();
- assert_eq!(first_generation, initial_generation.wrapping_add(1));
+ let first_attachment = context
+ .active_target
+ .runtime_slot
+ .page_attachment_id()
+ .expect("first Page attachment");
let first = context
.replace_loaded_page(Some(second_page))
.expect("first Page should be replaced");
- let second_generation = context.active_target.runtime_slot.loaded_page_generation();
- assert_eq!(second_generation, first_generation.wrapping_add(1));
+ let second_attachment = context
+ .active_target
+ .runtime_slot
+ .page_attachment_id()
+ .expect("second Page attachment");
+ assert_ne!(second_attachment, first_attachment);
let _ = first.close_async().await;
let second = context
.clear_loaded_page_with_reason(TargetPageAbsenceReason::TargetClosed)
.expect("second Page should be retired");
assert_eq!(
- context.active_target.runtime_slot.loaded_page_generation(),
- second_generation.wrapping_add(1)
+ context.active_target.runtime_slot.page_attachment_id(),
+ None
);
let _ = second.close_async().await;
}
diff --git a/moli-protocol/src/domains/activity/output_ingress/ordered_stream.rs b/moli-protocol/src/domains/activity/output_ingress/ordered_stream.rs
index 28caf7629..0ff561263 100644
--- a/moli-protocol/src/domains/activity/output_ingress/ordered_stream.rs
+++ b/moli-protocol/src/domains/activity/output_ingress/ordered_stream.rs
@@ -506,7 +506,7 @@ mod tests {
browser_context_id: "BID-test".to_owned(),
target_id: Some("TID-test".to_owned()),
renderer_page,
- page_owner: crate::conn::TargetPageResidenceIdentity::new(
+ page_owner: crate::conn::TargetPageResidenceIdentity::new_for_test(
"BID-test".to_owned(),
Some("TID-test".to_owned()),
1,
diff --git a/moli-protocol/src/domains/activity/output_work.rs b/moli-protocol/src/domains/activity/output_work.rs
index 9973c2c5d..da6dd1f23 100644
--- a/moli-protocol/src/domains/activity/output_work.rs
+++ b/moli-protocol/src/domains/activity/output_work.rs
@@ -93,7 +93,11 @@ impl ProtocolOutputWork {
frame_id: String,
loader_id: String,
) -> Self {
- let page_owner = TargetPageResidenceIdentity::new(browser_context_id, Some(target_id), 1);
+ let page_owner = TargetPageResidenceIdentity::new(
+ browser_context_id,
+ Some(target_id),
+ crate::conn::TargetPageAttachmentId::allocate(),
+ );
let attachments = session_ids
.into_iter()
.map(|session_id| {
diff --git a/moli-protocol/src/domains/activity/publication_route.rs b/moli-protocol/src/domains/activity/publication_route.rs
index b22ee8ca2..f720819b2 100644
--- a/moli-protocol/src/domains/activity/publication_route.rs
+++ b/moli-protocol/src/domains/activity/publication_route.rs
@@ -167,12 +167,12 @@ impl RendererPublicationOwner {
};
let projection = if runtime_slot.routes_current_renderer_page_owner(
*renderer_page,
- page_owner.loaded_page_generation(),
+ page_owner.page_attachment_id(),
) {
RendererPublicationProjection::CurrentPage
} else if runtime_slot.routes_retiring_renderer_page_owner(
*renderer_page,
- page_owner.loaded_page_generation(),
+ page_owner.page_attachment_id(),
) {
RendererPublicationProjection::RetiringNetworkOnly
} else {
diff --git a/moli-protocol/src/domains/activity/runtime_command_barrier.rs b/moli-protocol/src/domains/activity/runtime_command_barrier.rs
index f71d15093..86f4d03cb 100644
--- a/moli-protocol/src/domains/activity/runtime_command_barrier.rs
+++ b/moli-protocol/src/domains/activity/runtime_command_barrier.rs
@@ -945,12 +945,9 @@ mod tests {
let mut conn = connection_with_loaded_page().await;
let mut barriers = RuntimeCommandOutputBarriers::default();
let permit = admit_registered_command(&mut conn, &mut barriers, 21);
- let source_owner = conn
- .target_page_residence_identity_for_session(Some(SESSION_ID))
- .expect("source Page should have an exact residence");
conn.runtime_session_owner_slot_mut(Some(SESSION_ID))
.expect("runtime slot should remain installed")
- .set_loaded_page_generation(source_owner.loaded_page_generation() + 1);
+ .replace_page_attachment_id_for_test();
let mut command_context = CommandDispatchContext::default();
route_same_document_navigation(
@@ -986,9 +983,6 @@ mod tests {
let mut conn = connection_with_loaded_page().await;
let mut barriers = RuntimeCommandOutputBarriers::default();
let permit = admit_registered_command(&mut conn, &mut barriers, 30);
- let source_owner = conn
- .target_page_residence_identity_for_session(Some(SESSION_ID))
- .expect("source Page should have an exact residence");
let mut command_context = CommandDispatchContext::default();
route_top_level_navigation_for_command(
@@ -1003,7 +997,7 @@ mod tests {
conn.runtime_session_owner_slot_mut(Some(SESSION_ID))
.expect("runtime slot should remain installed")
- .set_loaded_page_generation(source_owner.loaded_page_generation() + 1);
+ .replace_page_attachment_id_for_test();
assert_eq!(
barriers
.release(&mut conn, permit, &mut command_context)
diff --git a/moli-protocol/src/domains/fetch/subresource.rs b/moli-protocol/src/domains/fetch/subresource.rs
index 125937843..f73ad3ed3 100644
--- a/moli-protocol/src/domains/fetch/subresource.rs
+++ b/moli-protocol/src/domains/fetch/subresource.rs
@@ -812,7 +812,7 @@ mod tests {
.expect("browser context should remain installed")
.active_target
.runtime_slot
- .set_loaded_page_generation(page_owner.loaded_page_generation() + 1);
+ .replace_page_attachment_id_for_test();
let mut events = Vec::new();
super::emit_subresource_fetch_pause_outputs(
diff --git a/moli-protocol/src/domains/fetch/tests/basics.rs b/moli-protocol/src/domains/fetch/tests/basics.rs
index ad131a2ad..0921d0109 100644
--- a/moli-protocol/src/domains/fetch/tests/basics.rs
+++ b/moli-protocol/src/domains/fetch/tests/basics.rs
@@ -27,10 +27,10 @@ fn pending_subresource_fetch_with_owner_kind(
) -> PendingSubresourceFetchRequest {
PendingSubresourceFetchRequest {
residence: crate::conn::PendingSubresourceFetchResidence::InstalledPage(
- crate::conn::TargetPageResidenceIdentity::new(
+ crate::conn::TargetPageResidenceIdentity::new_for_test(
"BID-session-fetch".to_owned(),
Some("TID-session-fetch".to_owned()),
- 0,
+ 1,
),
),
owner_session_id: Some(owner_session_id.to_owned()),
@@ -52,10 +52,10 @@ fn pending_subresource_fetch_auth(
owner_session_id: &str,
) -> PendingSubresourceFetchAuthRequest {
PendingSubresourceFetchAuthRequest {
- page_owner: crate::conn::TargetPageResidenceIdentity::new(
+ page_owner: crate::conn::TargetPageResidenceIdentity::new_for_test(
"BID-session-fetch".to_owned(),
Some("TID-session-fetch".to_owned()),
- 0,
+ 1,
),
owner_session_id: Some(owner_session_id.to_owned()),
action_session_id: Some(owner_session_id.to_owned()),
diff --git a/moli-protocol/src/domains/fetch/tests/command_correlation.rs b/moli-protocol/src/domains/fetch/tests/command_correlation.rs
index 24405d610..5fa20f0cc 100644
--- a/moli-protocol/src/domains/fetch/tests/command_correlation.rs
+++ b/moli-protocol/src/domains/fetch/tests/command_correlation.rs
@@ -180,7 +180,7 @@ async fn continue_request_registers_correlation_before_renderer_completion() {
}
#[tokio::test(flavor = "multi_thread")]
-async fn pending_fetch_command_state_is_bound_to_loaded_page_generation() {
+async fn pending_fetch_command_state_is_bound_to_page_attachment() {
let mut ctx = context_with_loaded_fetch_page().await;
let initial_owner = ctx
.conn
@@ -198,7 +198,7 @@ async fn pending_fetch_command_state_is_bound_to_loaded_page_generation() {
ctx.conn
.runtime_session_owner_slot_mut(Some("SID-1"))
.expect("runtime owner should remain addressable")
- .set_loaded_page_generation(initial_owner.loaded_page_generation().wrapping_add(1));
+ .replace_page_attachment_id_for_test();
assert!(
ctx.conn
.take_pending_subresource_fetch_request_for_action_session_owner(
@@ -287,7 +287,7 @@ async fn completed_continue_atomically_claims_a_pause_still_pending_publication(
ctx.conn
.runtime_session_owner_slot_mut(Some("SID-1"))
.expect("runtime owner should remain addressable")
- .set_loaded_page_generation(page_owner.loaded_page_generation().wrapping_add(1));
+ .replace_page_attachment_id_for_test();
let replacement_owner = ctx
.conn
.target_page_residence_identity_for_session(Some("SID-1"))
@@ -348,7 +348,7 @@ async fn continuation_claim_preserves_state_owned_by_a_different_page_residence(
ctx.conn
.runtime_session_owner_slot_mut(Some("SID-1"))
.expect("runtime owner should remain addressable")
- .set_loaded_page_generation(retired_owner.loaded_page_generation().wrapping_add(1));
+ .replace_page_attachment_id_for_test();
let replacement_owner = ctx
.conn
.target_page_residence_identity_for_session(Some("SID-1"))
@@ -380,7 +380,7 @@ async fn continuation_claim_preserves_state_owned_by_a_different_page_residence(
ctx.conn
.runtime_session_owner_slot_mut(Some("SID-1"))
.expect("runtime owner should remain addressable")
- .set_loaded_page_generation(retired_owner.loaded_page_generation());
+ .install_page_attachment_id_for_test(retired_owner.page_attachment_id());
let ClaimedSubresourceContinueRequest::InFlight(in_flight) = ctx
.conn
.claim_subresource_continue_request_for_session_owner(
@@ -414,7 +414,7 @@ async fn continuation_claim_preserves_state_owned_by_a_different_page_residence(
}
#[tokio::test(flavor = "multi_thread")]
-async fn pending_fetch_auth_state_is_bound_to_loaded_page_generation() {
+async fn pending_fetch_auth_state_is_bound_to_page_attachment() {
let mut ctx = context_with_loaded_fetch_page().await;
let initial_owner = ctx
.conn
@@ -432,7 +432,7 @@ async fn pending_fetch_auth_state_is_bound_to_loaded_page_generation() {
ctx.conn
.runtime_session_owner_slot_mut(Some("SID-1"))
.expect("runtime owner should remain addressable")
- .set_loaded_page_generation(initial_owner.loaded_page_generation().wrapping_add(1));
+ .replace_page_attachment_id_for_test();
assert!(
ctx.conn
.take_pending_subresource_fetch_auth_request_for_action_session_owner(
@@ -472,7 +472,7 @@ async fn pending_fetch_auth_state_is_bound_to_loaded_page_generation() {
}
#[tokio::test(flavor = "multi_thread")]
-async fn pending_fetch_response_state_is_bound_to_loaded_page_generation() {
+async fn pending_fetch_response_state_is_bound_to_page_attachment() {
let mut ctx = context_with_loaded_fetch_page().await;
let initial_owner = ctx
.conn
@@ -490,7 +490,7 @@ async fn pending_fetch_response_state_is_bound_to_loaded_page_generation() {
ctx.conn
.runtime_session_owner_slot_mut(Some("SID-1"))
.expect("runtime owner should remain addressable")
- .set_loaded_page_generation(initial_owner.loaded_page_generation().wrapping_add(1));
+ .replace_page_attachment_id_for_test();
assert!(
ctx.conn
.take_pending_subresource_fetch_response_request_for_action_session_owner(
diff --git a/moli-protocol/src/domains/input.rs b/moli-protocol/src/domains/input.rs
index baa993ab0..11944be95 100644
--- a/moli-protocol/src/domains/input.rs
+++ b/moli-protocol/src/domains/input.rs
@@ -2076,8 +2076,11 @@ mod producer_tests {
#[test]
fn input_prepared_slot_keeps_download_and_file_chooser_payloads_separate() {
let source_document = renderer_document_identity_for_test(1, 1);
- let owner =
- TargetPageResidenceIdentity::new("BID-slot".to_owned(), Some("TID-slot".to_owned()), 1);
+ let owner = TargetPageResidenceIdentity::new_for_test(
+ "BID-slot".to_owned(),
+ Some("TID-slot".to_owned()),
+ 1,
+ );
let mut slot = super::InputPreparedOutputSlot::from_outputs(super::InputPreparedOutputs {
download_activations: vec![RendererPendingDownloadActivation {
url: "https://example.test/download".to_owned(),
@@ -2372,7 +2375,7 @@ mod producer_tests {
.expect("source file chooser should prepare");
conn.runtime_session_owner_slot_mut(Some("SID-page-replacement"))
.expect("test runtime slot should exist")
- .set_loaded_page_generation(owner.loaded_page_generation() + 1);
+ .replace_page_attachment_id_for_test();
let replacement_document = renderer_document_identity_for_test(2, 2);
bind_renderer_document_for_test(
&mut conn,
diff --git a/moli-protocol/src/domains/input/file_chooser.rs b/moli-protocol/src/domains/input/file_chooser.rs
index 9e67662ac..f772d7443 100644
--- a/moli-protocol/src/domains/input/file_chooser.rs
+++ b/moli-protocol/src/domains/input/file_chooser.rs
@@ -15,8 +15,8 @@ use crate::devtools_runtime::{
/// The renderer resolves a live source node to a backend id before this value
/// is built. Capture resolves the compact root-frame representation once.
/// Apply may survive `document.open()` within the same Page, but a replacement
-/// Page generation retires the prepared activation before a colliding backend
-/// id can be observed.
+/// Page attachment replacement retires the prepared activation before a
+/// colliding backend id can be observed.
#[derive(Debug, Eq, PartialEq)]
pub(super) struct PreparedFileChooserActivation {
page_owner: TargetPageResidenceIdentity,
@@ -150,7 +150,7 @@ fn trace_stale_activation(session_id: Option<&str>, activation: &PreparedFileCho
backend_node_id = activation.backend_node_id,
browser_context_id = activation.page_owner.browser_context_id(),
target_id = activation.page_owner.target_id(),
- loaded_page_generation = activation.page_owner.loaded_page_generation(),
+ page_attachment_id = activation.page_owner.page_attachment_id().get(),
"dropping file chooser produced by a stale Page residence"
);
}
diff --git a/moli-protocol/src/domains/network/activity.rs b/moli-protocol/src/domains/network/activity.rs
index 14c90b8ea..2eea0f5f8 100644
--- a/moli-protocol/src/domains/network/activity.rs
+++ b/moli-protocol/src/domains/network/activity.rs
@@ -715,7 +715,7 @@ mod tests {
conn.runtime_session_owner_slot_mut(Some("SID-collision"))
.expect("runtime owner should remain addressable")
- .set_loaded_page_generation(1);
+ .replace_page_attachment_id_for_test();
let replacement_owner = conn
.target_page_residence_identity_for_session(Some("SID-collision"))
.expect("replacement Page residence should exist");
diff --git a/moli-protocol/src/domains/page.rs b/moli-protocol/src/domains/page.rs
index 46d237509..07af34630 100644
--- a/moli-protocol/src/domains/page.rs
+++ b/moli-protocol/src/domains/page.rs
@@ -2285,7 +2285,7 @@ pub(crate) async fn navigate_page_owned_top_level_location_background_events_asy
?source_document,
browser_context_id = owner.browser_context_id(),
target_id = owner.target_id(),
- loaded_page_generation = owner.loaded_page_generation(),
+ page_attachment_id = owner.page_attachment_id().get(),
url = navigation.url(),
"dropping top-level location navigation produced by a stale Page residence"
);
@@ -3281,7 +3281,7 @@ mod producer_tests {
));
conn.runtime_session_owner_slot_mut(Some("SID-dialog-stale-page"))
.expect("test target runtime slot")
- .set_loaded_page_generation(page_owner.loaded_page_generation() + 1);
+ .replace_page_attachment_id_for_test();
let mut out = Vec::new();
super::emit_javascript_dialog_activity_background_events_async(
@@ -4448,10 +4448,9 @@ mod producer_tests {
"SID-child-page-owner",
source_document,
);
- let source_owner = page_residence_identity_for_test(&conn, "SID-child-page-owner");
conn.runtime_session_owner_slot_mut(Some("SID-child-page-owner"))
.expect("test runtime owner")
- .set_loaded_page_generation(source_owner.loaded_page_generation() + 1);
+ .replace_page_attachment_id_for_test();
let mut events = Vec::new();
super::emit_prepared_child_frame_activity(&mut conn, &mut events, activity, None).await;
@@ -4991,7 +4990,7 @@ mod producer_tests {
let owner = page_residence_identity_for_test(&conn, "SID-stale-page-same-document");
conn.runtime_session_owner_slot_mut(Some("SID-stale-page-same-document"))
.expect("test runtime slot should exist")
- .set_loaded_page_generation(owner.loaded_page_generation() + 1);
+ .replace_page_attachment_id_for_test();
let mut prepared =
ProtocolOutputPayloads::from_slot(super::PagePreparedOutputSlot::from_outputs(
super::PagePreparedOutputs::from_same_document_navigations_for_test(
@@ -5181,7 +5180,7 @@ mod producer_tests {
let owner = page_residence_identity_for_test(&conn, "SID-stale-page-location");
conn.runtime_session_owner_slot_mut(Some("SID-stale-page-location"))
.expect("test runtime slot should exist")
- .set_loaded_page_generation(owner.loaded_page_generation() + 1);
+ .replace_page_attachment_id_for_test();
let mut prepared =
ProtocolOutputPayloads::from_slot(super::PagePreparedOutputSlot::from_outputs(
super::PagePreparedOutputs::from_top_level_location_navigation_for_test(
diff --git a/moli-protocol/src/domains/page/javascript_dialog.rs b/moli-protocol/src/domains/page/javascript_dialog.rs
index 830f346bc..9d800c609 100644
--- a/moli-protocol/src/domains/page/javascript_dialog.rs
+++ b/moli-protocol/src/domains/page/javascript_dialog.rs
@@ -81,7 +81,7 @@ fn trace_stale_source(dialog: &PreparedJavaScriptDialog) {
source_document = ?dialog.source_document(),
browser_context_id = page_owner.browser_context_id(),
target_id = page_owner.target_id(),
- loaded_page_generation = page_owner.loaded_page_generation(),
+ page_attachment_id = page_owner.page_attachment_id().get(),
route = ?dialog.route(),
"dismissing JavaScript dialog from a stale Page attachment or dialog scope"
);
diff --git a/moli-protocol/src/domains/page/navigation.rs b/moli-protocol/src/domains/page/navigation.rs
index e788c3bb3..aa0f507a8 100644
--- a/moli-protocol/src/domains/page/navigation.rs
+++ b/moli-protocol/src/domains/page/navigation.rs
@@ -3605,7 +3605,7 @@ pub(crate) async fn emit_same_document_navigation_background_events_async(
?source_document,
browser_context_id = navigation.owner().browser_context_id(),
target_id = navigation.owner().target_id(),
- loaded_page_generation = navigation.owner().loaded_page_generation(),
+ page_attachment_id = navigation.owner().page_attachment_id().get(),
"dropping same-document navigation produced by a stale Page residence"
);
continue;
diff --git a/moli-protocol/src/domains/page/popup.rs b/moli-protocol/src/domains/page/popup.rs
index b3da72706..e49de6216 100644
--- a/moli-protocol/src/domains/page/popup.rs
+++ b/moli-protocol/src/domains/page/popup.rs
@@ -173,7 +173,7 @@ fn resolve_devtools_opener(
tracing::debug!(
browser_context_id = page_owner.browser_context_id(),
target_id = page_owner.target_id(),
- loaded_page_generation = page_owner.loaded_page_generation(),
+ page_attachment_id = page_owner.page_attachment_id().get(),
?root_document,
?window,
"popup action retained after its exact opener browsing context disappeared"
@@ -207,7 +207,7 @@ mod tests {
use super::*;
fn page_owner(browser_context_id: &str, target_id: &str) -> TargetPageResidenceIdentity {
- TargetPageResidenceIdentity::new(
+ TargetPageResidenceIdentity::new_for_test(
browser_context_id.to_owned(),
Some(target_id.to_owned()),
7,
diff --git a/moli-protocol/src/domains/page/tests/dialog.rs b/moli-protocol/src/domains/page/tests/dialog.rs
index 9fed3993e..5c9d10bb6 100644
--- a/moli-protocol/src/domains/page/tests/dialog.rs
+++ b/moli-protocol/src/domains/page/tests/dialog.rs
@@ -105,10 +105,10 @@ fn retiring_page_scope_and_clearing_dialog_state_dismisses_installed_dialog() {
async fn pending_javascript_dialogs_are_preserved_per_parked_target() {
fn dialog(target_id: &str, message: &str) -> crate::conn::TargetJavaScriptDialog {
target_dialog_for_test(
- crate::conn::TargetPageResidenceIdentity::new(
+ crate::conn::TargetPageResidenceIdentity::new_for_test(
"BID-1".to_owned(),
Some(target_id.to_owned()),
- 0,
+ 1,
),
target_id,
"alert",
@@ -322,10 +322,10 @@ async fn get_javascript_dialog_text_peeks_without_closing_dialog() {
.page_session_state
.javascript_dialog_state
.push(target_dialog_for_test(
- crate::conn::TargetPageResidenceIdentity::new(
+ crate::conn::TargetPageResidenceIdentity::new_for_test(
"BID-1".to_owned(),
Some("TID-1".to_owned()),
- 0,
+ 1,
),
"TID-1",
"alert",
@@ -409,10 +409,10 @@ async fn set_javascript_dialog_prompt_text_is_used_when_accepting_prompt() {
.page_session_state
.javascript_dialog_state
.push(target_dialog_for_test(
- crate::conn::TargetPageResidenceIdentity::new(
+ crate::conn::TargetPageResidenceIdentity::new_for_test(
"BID-1".to_owned(),
Some("TID-1".to_owned()),
- 0,
+ 1,
),
"TID-1",
"prompt",
@@ -623,7 +623,7 @@ async fn handle_javascript_dialog_rejects_dialog_without_current_page_residence(
.page_session_state
.javascript_dialog_state
.push(target_dialog_for_test(
- crate::conn::TargetPageResidenceIdentity::new(
+ crate::conn::TargetPageResidenceIdentity::new_for_test(
"BID-dialog-missing-frame".to_owned(),
Some("retired-target".to_owned()),
1,
diff --git a/moli-protocol/src/domains/page/tests/document_content.rs b/moli-protocol/src/domains/page/tests/document_content.rs
index fe5f7a226..ac95647d3 100644
--- a/moli-protocol/src/domains/page/tests/document_content.rs
+++ b/moli-protocol/src/domains/page/tests/document_content.rs
@@ -2,19 +2,22 @@ use super::*;
async fn install_document_content_test_page(ctx: &mut TestContext, url: &str) {
load_bc_with_session(ctx, "BID-set-content", "TID-1", "SID-1", "about:blank");
+ let committed_document = {
+ let browser_context = ctx.conn.browser_context.as_mut().expect("browser context");
+ browser_context.set_target_url(url.to_owned());
+ browser_context
+ .start_document_navigation_for_active_target(LOADER_ID.to_owned())
+ .expect("document-content test navigation should start")
+ };
let mut navigation = ctx
.conn
- .load_navigation_via_runtime_async(url)
+ .load_navigation_via_runtime_for_session_owner_async(Some("SID-1"), url)
.await
.expect("document-content test page should load");
let navigation_engine = navigation.navigation_engine.take();
let artifacts = navigation.page_creation_artifacts;
- let committed_document = {
+ {
let browser_context = ctx.conn.browser_context.as_mut().expect("browser context");
- browser_context.set_target_url(url.to_owned());
- let committed_document = browser_context
- .start_document_navigation_for_active_target(LOADER_ID.to_owned())
- .expect("document-content test navigation should start");
let renderer_agent_candidate = browser_context
.active_target
.runtime_slot
@@ -43,8 +46,7 @@ async fn install_document_content_test_page(ctx: &mut TestContext, url: &str) {
.is_empty(),
"the fixture should not leave buffered Inspector output behind"
);
- committed_document
- };
+ }
let (binding, _) = ctx.conn.bind_renderer_document_lifecycle_for_session_owner(
Some("SID-1"),
artifacts,
diff --git a/moli-protocol/src/domains/page/tests/lifecycle.rs b/moli-protocol/src/domains/page/tests/lifecycle.rs
index eca2d9ad8..1ba13ee63 100644
--- a/moli-protocol/src/domains/page/tests/lifecycle.rs
+++ b/moli-protocol/src/domains/page/tests/lifecycle.rs
@@ -169,10 +169,10 @@ fn mark_page_domain_enabled(state: &mut crate::conn::TargetPageSessionState) {
.page_screencast
.start(crate::conn::PageScreencastConfig::default());
state.javascript_dialog_state.push(target_dialog_for_test(
- crate::conn::TargetPageResidenceIdentity::new(
+ crate::conn::TargetPageResidenceIdentity::new_for_test(
"BID-dialog".to_owned(),
Some("TID-dialog".to_owned()),
- 0,
+ 1,
),
"TID-dialog",
"alert",
@@ -239,10 +239,10 @@ fn enable_page_domain_for_session(conn: &mut crate::conn::CdpConnection, session
.page_session_state
.javascript_dialog_state
.push(target_dialog_for_test(
- crate::conn::TargetPageResidenceIdentity::new(
+ crate::conn::TargetPageResidenceIdentity::new_for_test(
"BID-dialog".to_owned(),
Some("TID-dialog".to_owned()),
- 0,
+ 1,
),
"TID-dialog",
"alert",
diff --git a/moli-protocol/src/domains/runtime/activity.rs b/moli-protocol/src/domains/runtime/activity.rs
index 7ffd9f310..e5dfa5fe7 100644
--- a/moli-protocol/src/domains/runtime/activity.rs
+++ b/moli-protocol/src/domains/runtime/activity.rs
@@ -662,12 +662,12 @@ mod tests {
}
#[tokio::test(flavor = "multi_thread")]
- async fn runtime_binding_drain_discards_a_replaced_page_generation() {
+ async fn runtime_binding_drain_discards_a_replaced_page_attachment() {
let (mut conn, attachment) = runtime_binding_attachment_fixture();
let mut prepared = prepared_runtime_binding_calls(attachment);
conn.runtime_session_owner_slot_mut(Some("SID-1"))
.expect("Runtime binding target")
- .bump_loaded_page_generation();
+ .replace_page_attachment_id_for_test();
let mut command_context = CommandDispatchContext::default();
let mut context = ProtocolOutputProjectionContext {
session_id: Some("SID-1"),
@@ -683,7 +683,7 @@ mod tests {
assert!(
context.command.take_protocol_events().is_empty(),
- "a binding call captured from the old Page must not leak through a replacement generation"
+ "a binding call captured from the old Page must not leak through a replacement attachment"
);
}
@@ -693,7 +693,7 @@ mod tests {
let mut outputs = runtime_binding_outputs(retired_attachment, "retired-page");
conn.runtime_session_owner_slot_mut(Some("SID-1"))
.expect("Runtime binding target")
- .bump_loaded_page_generation();
+ .replace_page_attachment_id_for_test();
let current_attachment = conn
.target_page_protocol_attachment_identity_for_session(Some("SID-1"))
.expect("replacement Runtime binding attachment");
@@ -808,12 +808,12 @@ mod tests {
);
conn.runtime_session_owner_slot_mut(Some("SID-1"))
.expect("Runtime inspector target")
- .bump_loaded_page_generation();
+ .replace_page_attachment_id_for_test();
let events = drain_runtime_inspector_outputs(&mut conn, outputs, Some("SID-1")).await;
assert!(
events.is_empty(),
- "an inspector response captured from an old Page generation must not reach its replacement"
+ "an inspector response captured from an old Page attachment must not reach its replacement"
);
}
@@ -892,7 +892,7 @@ mod tests {
);
conn.runtime_session_owner_slot_mut(Some("SID-1"))
.expect("Runtime inspector target")
- .bump_loaded_page_generation();
+ .replace_page_attachment_id_for_test();
outputs.extend(renderer_inspector_outputs(
&conn,
Some("SID-1"),
diff --git a/moli-protocol/src/domains/runtime/tests/evaluate.rs b/moli-protocol/src/domains/runtime/tests/evaluate.rs
index 4b8661f83..a1b4a8a5d 100644
--- a/moli-protocol/src/domains/runtime/tests/evaluate.rs
+++ b/moli-protocol/src/domains/runtime/tests/evaluate.rs
@@ -2491,7 +2491,7 @@ async fn page_navigate_network_failure_commits_error_document() {
ctx.conn
.target_page_residence_identity_for_session(Some("SID-1")),
Some(before_target_page),
- "current master installs navigation Documents as a new target Page generation"
+ "current master installs navigation Documents as a new target Page attachment"
);
assert_ne!(
ctx.conn
diff --git a/moli-protocol/src/domains/runtime/tests/mod.rs b/moli-protocol/src/domains/runtime/tests/mod.rs
index eda36803a..5ec7fa13b 100644
--- a/moli-protocol/src/domains/runtime/tests/mod.rs
+++ b/moli-protocol/src/domains/runtime/tests/mod.rs
@@ -49,7 +49,7 @@ fn load_dedicated_worker_target(ctx: &mut TestContext, session_id: &str) {
let browser_context_id = "BID-dedicated".to_owned();
let mut bc = BrowserContext::new(browser_context_id.clone());
let mut target = crate::conn::DedicatedWorkerTargetState::new(
- crate::conn::TargetPageResidenceIdentity::new(browser_context_id, None, 0),
+ crate::conn::TargetPageResidenceIdentity::new_for_test(browser_context_id, None, 1),
moli_core::RendererOwnerLocalHostId::new_for_testing(1),
82,
"TID-dedicated-worker".to_owned(),
diff --git a/moli-protocol/src/domains/target/worker_target.rs b/moli-protocol/src/domains/target/worker_target.rs
index 941e80311..e4e629604 100644
--- a/moli-protocol/src/domains/target/worker_target.rs
+++ b/moli-protocol/src/domains/target/worker_target.rs
@@ -3700,10 +3700,14 @@ mod tests {
let mut conn = CdpConnection::default();
let mut context = BrowserContext::new("BID-1".to_owned());
context.set_active_target_id("TID-page");
+ let page_attachment_id = context
+ .active_target
+ .runtime_slot
+ .set_page_attachment_id_for_test(1);
let owner_page = TargetPageResidenceIdentity::new(
"BID-1".to_owned(),
Some("TID-page".to_owned()),
- context.active_target.runtime_slot.loaded_page_generation(),
+ page_attachment_id,
);
conn.browser_context = Some(context);
let owner_renderer_page = RendererPageResidenceIdentity::new(
@@ -4658,7 +4662,7 @@ mod tests {
let _ = drain_target_lifecycle_events_for_test(&mut conn, loaded).await;
let retained_target_id = "TID-other-worker".to_owned();
- let retained_owner = TargetPageResidenceIdentity::new(
+ let retained_owner = TargetPageResidenceIdentity::new_for_test(
"BID-1".to_owned(),
Some("TID-other-page".to_owned()),
7,
@@ -4681,7 +4685,7 @@ mod tests {
.unwrap()
.active_target
.runtime_slot
- .bump_loaded_page_generation();
+ .replace_page_attachment_id_for_test();
let messages = protocol_messages(
&retire_dedicated_worker_targets_for_replaced_page_async(&mut conn, &owner_page).await,
);