Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor: bind input cleanup to page attachments

ldm0353bf19d2888
diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rs
index 49a1f1b37..de9780a62 100644
--- a/moli-protocol/src/conn.rs
+++ b/moli-protocol/src/conn.rs
@@ -543,7 +543,7 @@ pub(crate) use state::{
ServiceWorkerRuntimeExceptionSnapshot, ServiceWorkerTargetState, SharedWorkerTargetState,
SiteDataClearOptions, TargetIdentityState, TargetInitialEmptyDocumentCreator, TargetOwnerState,
TargetPageAttachmentId, TargetPageProtocolAttachmentIdentity, TargetPageResidenceIdentity,
- TargetPageResidenceObservation, TargetPageResidenceObserver, TargetPageSessionState,
+ TargetPageResidenceObservation, TargetPageResidenceToken, TargetPageSessionState,
TargetPreparedJavaScriptDialog, TargetPreparedJavaScriptDialogRoute,
TargetRootDocumentProtocolAttachmentIdentity, TargetRuntimeSlot,
TargetServiceWorkerProtocolAttachmentIdentity, TargetServiceWorkerProtocolAttachmentRetirement,
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 f5406b21d..8617dc5e4 100644
--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs
+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs
@@ -3021,24 +3021,20 @@ impl CdpConnection {
== Some(expected)
}
- /// Observes replacement of the exact installed Page that admitted work.
- pub(crate) fn register_target_page_residence_observer_for_session(
+ /// Captures the lifetime of the concrete Page attachment currently
+ /// addressed by `session_id`.
+ ///
+ /// The returned token is owned by that attachment rather than by a numeric
+ /// slot generation. Moving the whole target slot preserves it; replacing
+ /// or clearing the installed Page terminates it directly.
+ pub(crate) fn capture_target_page_residence_token_for_session(
&mut self,
session_id: Option<&str>,
- expected: &TargetPageResidenceIdentity,
- ) -> crate::conn::TargetPageResidenceObserver {
- if !self.target_page_residence_identity_is_current_for_session(session_id, expected) {
- return crate::conn::TargetPageResidenceObserver::resolved(
- crate::conn::TargetPageResidenceObservation::Superseded,
- );
- }
- let Ok(slot) = self.runtime_session_owner_slot_mut(session_id) else {
- return crate::conn::TargetPageResidenceObserver::resolved(
- crate::conn::TargetPageResidenceObservation::Unavailable,
- );
- };
- slot.page_slot_mut()
- .register_page_residence_observer(expected.loaded_page_generation())
+ ) -> Option<crate::conn::TargetPageResidenceToken> {
+ self.runtime_session_owner_slot_mut(session_id)
+ .ok()?
+ .page_slot_mut()
+ .page_residence_token()
}
/// Captures the exact protocol attachment currently addressing a Page.
diff --git a/moli-protocol/src/conn/state/mod.rs b/moli-protocol/src/conn/state/mod.rs
index e246970a4..2711f21b5 100644
--- a/moli-protocol/src/conn/state/mod.rs
+++ b/moli-protocol/src/conn/state/mod.rs
@@ -12,7 +12,7 @@ mod inspector;
mod javascript_dialog;
mod navigation;
mod navigation_outcome;
-mod page_residence_observer;
+mod page_residence_token;
mod page_resource;
mod page_slot;
mod parking;
@@ -57,9 +57,7 @@ pub(crate) use devtools_session::{
pub(crate) use document_lifecycle_observer::{
RendererDocumentLifecycleObservation, RendererDocumentLifecycleObserver,
};
-pub(crate) use page_residence_observer::{
- TargetPageResidenceObservation, TargetPageResidenceObserver,
-};
+pub(crate) use page_residence_token::{TargetPageResidenceObservation, TargetPageResidenceToken};
pub use bounds::BrowserWindowBounds;
diff --git a/moli-protocol/src/conn/state/page_residence_observer.rs b/moli-protocol/src/conn/state/page_residence_observer.rs
deleted file mode 100644
index bb271b4c9..000000000
--- a/moli-protocol/src/conn/state/page_residence_observer.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-use tokio::sync::watch;
-
-/// Terminal result of observing one exact installed Page residence.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub(crate) enum TargetPageResidenceObservation {
- Superseded,
- Unavailable,
-}
-
-/// Move-only notification that an installed Page generation was replaced.
-///
-/// The observer is tied directly to the target's Page slot. Moving that slot
-/// between active and background storage preserves the observation; advancing
-/// its installed Page generation publishes `Superseded`. Losing the slot
-/// entirely closes the channel and produces `Unavailable`.
-#[derive(Debug)]
-pub(crate) struct TargetPageResidenceObserver {
- state: TargetPageResidenceObserverState,
-}
-
-#[derive(Debug)]
-enum TargetPageResidenceObserverState {
- Watching {
- expected_generation: u64,
- receiver: watch::Receiver<u64>,
- },
- Resolved(TargetPageResidenceObservation),
-}
-
-impl TargetPageResidenceObserver {
- pub(crate) fn new(expected_generation: u64, receiver: watch::Receiver<u64>) -> Self {
- Self {
- state: TargetPageResidenceObserverState::Watching {
- expected_generation,
- receiver,
- },
- }
- }
-
- pub(crate) fn resolved(observation: TargetPageResidenceObservation) -> Self {
- Self {
- state: TargetPageResidenceObserverState::Resolved(observation),
- }
- }
-
- pub(crate) async fn wait(self) -> TargetPageResidenceObservation {
- let (expected_generation, mut receiver) = match self.state {
- TargetPageResidenceObserverState::Watching {
- expected_generation,
- receiver,
- } => (expected_generation, receiver),
- TargetPageResidenceObserverState::Resolved(observation) => return observation,
- };
- loop {
- if *receiver.borrow_and_update() != expected_generation {
- return TargetPageResidenceObservation::Superseded;
- }
- if receiver.changed().await.is_err() {
- return TargetPageResidenceObservation::Unavailable;
- }
- }
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[tokio::test]
- async fn generation_change_publishes_superseded() {
- let (publisher, receiver) = watch::channel(7);
- let observer = TargetPageResidenceObserver::new(7, receiver);
-
- publisher.send_replace(8);
-
- assert_eq!(
- observer.wait().await,
- TargetPageResidenceObservation::Superseded
- );
- }
-
- #[tokio::test]
- async fn publisher_loss_reports_unavailable() {
- let (publisher, receiver) = watch::channel(7);
- let observer = TargetPageResidenceObserver::new(7, receiver);
-
- drop(publisher);
-
- assert_eq!(
- observer.wait().await,
- TargetPageResidenceObservation::Unavailable
- );
- }
-}
diff --git a/moli-protocol/src/conn/state/page_residence_token.rs b/moli-protocol/src/conn/state/page_residence_token.rs
new file mode 100644
index 000000000..c00e23252
--- /dev/null
+++ b/moli-protocol/src/conn/state/page_residence_token.rs
@@ -0,0 +1,114 @@
+use tokio::sync::watch;
+
+use super::TargetPageAttachmentId;
+
+/// Terminal result of observing one exact installed Page residence.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum TargetPageResidenceObservation {
+ Superseded,
+ Unavailable,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum TargetPageResidenceState {
+ Live(TargetPageAttachmentId),
+ Superseded(TargetPageAttachmentId),
+}
+
+/// Slot-owned lifetime for one concrete Page attachment.
+///
+/// Dropping this publisher without first superseding it means the owning slot
+/// disappeared unexpectedly. Replacing or clearing the installed Page must
+/// explicitly call `supersede`, which resolves every token for that attachment.
+#[derive(Debug)]
+pub(crate) struct TargetPageResidencePublisher {
+ sender: watch::Sender<TargetPageResidenceState>,
+}
+
+impl TargetPageResidencePublisher {
+ pub(crate) fn new(attachment_id: TargetPageAttachmentId) -> Self {
+ let (sender, _receiver) = watch::channel(TargetPageResidenceState::Live(attachment_id));
+ Self { sender }
+ }
+
+ pub(crate) fn token(&self) -> TargetPageResidenceToken {
+ TargetPageResidenceToken {
+ receiver: self.sender.subscribe(),
+ }
+ }
+
+ pub(crate) fn supersede(self) {
+ let attachment_id = match *self.sender.borrow() {
+ TargetPageResidenceState::Live(attachment_id)
+ | TargetPageResidenceState::Superseded(attachment_id) => attachment_id,
+ };
+ self.sender
+ .send_replace(TargetPageResidenceState::Superseded(attachment_id));
+ }
+}
+
+/// Move-only lifetime token for one concrete installed Page attachment.
+///
+/// Moving the target's whole Page slot preserves this token. Replacing or
+/// clearing that attachment resolves it as `Superseded`; losing the owning slot
+/// without an explicit lifecycle transition resolves it as `Unavailable`.
+#[derive(Debug)]
+pub(crate) struct TargetPageResidenceToken {
+ receiver: watch::Receiver<TargetPageResidenceState>,
+}
+
+impl TargetPageResidenceToken {
+ pub(crate) async fn wait(mut self) -> TargetPageResidenceObservation {
+ loop {
+ match *self.receiver.borrow_and_update() {
+ TargetPageResidenceState::Live(_) => {}
+ TargetPageResidenceState::Superseded(_) => {
+ return TargetPageResidenceObservation::Superseded;
+ }
+ }
+ if self.receiver.changed().await.is_err() {
+ return TargetPageResidenceObservation::Unavailable;
+ }
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn attachment_id(raw: u64) -> TargetPageAttachmentId {
+ TargetPageAttachmentId::from_raw_for_test(raw)
+ }
+
+ #[tokio::test]
+ async fn explicit_supersede_resolves_every_attachment_token() {
+ let publisher = TargetPageResidencePublisher::new(attachment_id(7));
+ let first = publisher.token();
+ let second = publisher.token();
+
+ publisher.supersede();
+
+ assert_eq!(
+ first.wait().await,
+ TargetPageResidenceObservation::Superseded
+ );
+ assert_eq!(
+ second.wait().await,
+ TargetPageResidenceObservation::Superseded
+ );
+ }
+
+ #[tokio::test]
+ async fn publisher_loss_reports_unavailable() {
+ let publisher = TargetPageResidencePublisher::new(attachment_id(7));
+ let token = publisher.token();
+
+ drop(publisher);
+
+ assert_eq!(
+ token.wait().await,
+ TargetPageResidenceObservation::Unavailable
+ );
+ }
+}
diff --git a/moli-protocol/src/conn/state/page_slot.rs b/moli-protocol/src/conn/state/page_slot.rs
index 1bd4cfc60..a99a4214b 100644
--- a/moli-protocol/src/conn/state/page_slot.rs
+++ b/moli-protocol/src/conn/state/page_slot.rs
@@ -14,7 +14,7 @@ use super::document_lifecycle_observer::{
RendererDocumentLifecycleObservation, RendererDocumentLifecycleObservationPublisher,
RendererDocumentLifecycleObserver,
};
-use super::page_residence_observer::{TargetPageResidenceObservation, TargetPageResidenceObserver};
+use super::page_residence_token::{TargetPageResidencePublisher, TargetPageResidenceToken};
use super::{NavigationRequestId, RendererPageResidenceIdentity, TargetPageAttachmentId};
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
@@ -333,7 +333,7 @@ pub(crate) struct TargetPageSlot {
loaded_page_absence_reason: TargetPageAbsenceReason,
page_attachment_id: Option<TargetPageAttachmentId>,
loaded_page_generation: u64,
- loaded_page_generation_publisher: Option<watch::Sender<u64>>,
+ page_residence_publisher: Option<TargetPageResidencePublisher>,
pending_navigation_request: Option<PendingNavigationRequest>,
committed_document_navigation: Option<DocumentNavigationToken>,
renderer_document_lifecycle: RendererDocumentLifecycleProtocolState,
@@ -484,7 +484,9 @@ impl TargetPageSlot {
self.loaded_page_absence_reason = absence_reason;
self.page_attachment_id = None;
}
- std::mem::replace(&mut self.loaded_page, page)
+ let previous = std::mem::replace(&mut self.loaded_page, page);
+ self.supersede_page_residence();
+ previous
}
pub(crate) fn replace_loaded_page(&mut self, page: Option<Page>) -> Option<Page> {
@@ -504,19 +506,18 @@ impl TargetPageSlot {
self.loaded_page_generation
}
- pub(crate) fn register_page_residence_observer(
- &mut self,
- expected_generation: u64,
- ) -> TargetPageResidenceObserver {
- if self.loaded_page_generation != expected_generation {
- return TargetPageResidenceObserver::resolved(
- TargetPageResidenceObservation::Superseded,
- );
- }
+ pub(crate) fn page_residence_token(&mut self) -> Option<TargetPageResidenceToken> {
+ let attachment_id = self.page_attachment_id?;
let publisher = self
- .loaded_page_generation_publisher
- .get_or_insert_with(|| watch::channel(self.loaded_page_generation).0);
- TargetPageResidenceObserver::new(expected_generation, publisher.subscribe())
+ .page_residence_publisher
+ .get_or_insert_with(|| TargetPageResidencePublisher::new(attachment_id));
+ Some(publisher.token())
+ }
+
+ fn supersede_page_residence(&mut self) {
+ if let Some(publisher) = self.page_residence_publisher.take() {
+ publisher.supersede();
+ }
}
fn advance_loaded_page_generation(&mut self) {
@@ -524,7 +525,6 @@ impl TargetPageSlot {
RendererDocumentLifecycleObservation::Superseded,
);
self.loaded_page_generation = self.loaded_page_generation.wrapping_add(1);
- self.publish_loaded_page_generation();
}
#[cfg(test)]
@@ -541,19 +541,16 @@ impl TargetPageSlot {
RendererDocumentLifecycleObservation::Superseded,
);
self.loaded_page_generation = generation;
- self.publish_loaded_page_generation();
- }
-
- fn publish_loaded_page_generation(&self) {
- if let Some(publisher) = self.loaded_page_generation_publisher.as_ref() {
- publisher.send_replace(self.loaded_page_generation);
- }
}
#[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);
+ if attachment_changed {
+ self.supersede_page_residence();
+ }
attachment_id
}
@@ -1360,6 +1357,42 @@ impl TargetPageSlot {
}
}
+#[cfg(test)]
+mod page_residence_tests {
+ use std::{
+ future::Future,
+ task::{Context, Poll, Waker},
+ };
+
+ use super::*;
+ use crate::conn::TargetPageResidenceObservation;
+
+ #[test]
+ fn attachment_token_ignores_generation_and_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"
+ );
+
+ slot.set_page_attachment_id_for_test(92);
+
+ assert!(matches!(
+ wait.as_mut().poll(&mut context),
+ Poll::Ready(TargetPageResidenceObservation::Superseded)
+ ));
+ }
+}
+
#[cfg(test)]
mod pending_renderer_page_tests {
use super::*;
diff --git a/moli-protocol/src/domains/input.rs b/moli-protocol/src/domains/input.rs
index 9cb4d5040..baa993ab0 100644
--- a/moli-protocol/src/domains/input.rs
+++ b/moli-protocol/src/domains/input.rs
@@ -1,6 +1,6 @@
use crate::conn::{
BackgroundProtocolEvent, CdpConnection, Cmd, CommandDispatchContext,
- TargetPageResidenceIdentity, TargetPageResidenceObservation, TargetPageResidenceObserver,
+ TargetPageResidenceIdentity, TargetPageResidenceObservation, TargetPageResidenceToken,
};
use crate::devtools_runtime::{
DevToolsCommand, DevToolsCommandContext, DevToolsCommandResult,
@@ -61,7 +61,7 @@ pub(crate) struct PendingInputCommandDispatch {
command_id: Option<u64>,
session_id: Option<String>,
owner: TargetPageResidenceIdentity,
- owner_observer: Option<TargetPageResidenceObserver>,
+ page_residence_token: Option<TargetPageResidenceToken>,
kind: PendingInputCommandKind,
pending: PendingInputOperation,
}
@@ -149,16 +149,16 @@ enum RendererInputWaitOutcome<T> {
async fn wait_for_renderer_input_or_page_replacement<T>(
completion: impl std::future::Future<Output = T>,
- owner_observer: Option<TargetPageResidenceObserver>,
+ page_residence_token: Option<TargetPageResidenceToken>,
) -> RendererInputWaitOutcome<T> {
- let Some(owner_observer) = owner_observer else {
+ let Some(page_residence_token) = page_residence_token else {
return RendererInputWaitOutcome::Completed(completion.await);
};
tokio::pin!(completion);
tokio::select! {
biased;
result = &mut completion => RendererInputWaitOutcome::Completed(result),
- observation = owner_observer.wait() => {
+ observation = page_residence_token.wait() => {
RendererInputWaitOutcome::PageResidence(observation)
}
}
@@ -174,7 +174,7 @@ impl PendingInputCommandDispatch {
PendingInputOperation::Page(pending) => {
match wait_for_renderer_input_or_page_replacement(
pending.wait(),
- self.owner_observer,
+ self.page_residence_token,
)
.await
{
@@ -193,7 +193,7 @@ impl PendingInputCommandDispatch {
PendingInputOperation::RendererAckHeldForTest => {
match wait_for_renderer_input_or_page_replacement(
std::future::pending::<std::convert::Infallible>(),
- self.owner_observer,
+ self.page_residence_token,
)
.await
{
@@ -223,7 +223,7 @@ impl PendingInputCommandDispatch {
// gives lifecycle smoke tests a deterministic outstanding callback;
// public CDP intentionally cannot pause that callback while also
// scheduling a replacement of the same Page owner.
- if !self.kind.uses_renderer_host_ack_cleanup() || self.owner_observer.is_none() {
+ if !self.kind.uses_renderer_host_ack_cleanup() || self.page_residence_token.is_none() {
return false;
}
self.pending = PendingInputOperation::RendererAckHeldForTest;
@@ -1015,17 +1015,22 @@ fn start_page_input_command(
let owner = conn
.target_page_residence_identity_for_session(command_session_id)
.ok_or_else(PendingInputCommandStartError::no_document_loaded)?;
+ let page_residence_token = if kind.uses_renderer_host_ack_cleanup() {
+ Some(
+ conn.capture_target_page_residence_token_for_session(command_session_id)
+ .ok_or_else(PendingInputCommandStartError::no_document_loaded)?,
+ )
+ } else {
+ None
+ };
let page = loaded_page_mut(conn, command_session_id)
.ok_or_else(PendingInputCommandStartError::no_document_loaded)?;
let pending = start(page).map_err(PendingInputCommandStartError::renderer_error)?;
- let owner_observer = kind.uses_renderer_host_ack_cleanup().then(|| {
- conn.register_target_page_residence_observer_for_session(command_session_id, &owner)
- });
Ok(Some(PendingInputCommandDispatch {
command_id,
session_id: command_session_id.map(str::to_owned),
owner,
- owner_observer,
+ page_residence_token,
kind,
pending: PendingInputOperation::Page(pending),
}))
diff --git a/moli-protocol/src/domains/input/tests.rs b/moli-protocol/src/domains/input/tests.rs
index 033474ac4..752c3a2fa 100644
--- a/moli-protocol/src/domains/input/tests.rs
+++ b/moli-protocol/src/domains/input/tests.rs
@@ -288,7 +288,7 @@ async fn completed_mouse_event_does_not_restore_replaced_page_state() {
command_id: Some(104),
session_id: None,
owner: original_owner.clone(),
- owner_observer: None,
+ page_residence_token: None,
kind: PendingInputCommandKind::DispatchMouseEvent,
pending: PendingInputOperation::Page(pending),
}
@@ -331,16 +331,19 @@ async fn pending_mouse_event_acknowledges_when_page_is_replaced_before_renderer_
.conn
.target_page_residence_identity_for_session(None)
.expect("the original Page should have a residence identity");
- let observer = ctx
+ let page_residence_token = ctx
.conn
- .register_target_page_residence_observer_for_session(None, &original_owner);
+ .capture_target_page_residence_token_for_session(None)
+ .expect("the original Page should expose its attachment lifetime");
let replacement_url = "data:text/html,<body>replacement-before-completion</body>";
ctx.install_navigation_fixture_for_session_owner(replacement_url, None)
.await;
- let wait =
- wait_for_renderer_input_or_page_replacement(std::future::pending::<()>(), Some(observer));
+ let wait = wait_for_renderer_input_or_page_replacement(
+ std::future::pending::<()>(),
+ Some(page_residence_token),
+ );
let outcome = tokio::time::timeout(std::time::Duration::from_secs(1), wait)
.await
.expect("Page replacement should settle the pending input wait");
@@ -370,13 +373,10 @@ async fn completed_renderer_ack_wins_when_page_replacement_is_already_observable
let mut ctx = TestContext::new();
with_loaded_document(&mut ctx, "<body>origin</body>").await;
- let original_owner = ctx
- .conn
- .target_page_residence_identity_for_session(None)
- .expect("the original Page should have a residence identity");
- let observer = ctx
+ let page_residence_token = ctx
.conn
- .register_target_page_residence_observer_for_session(None, &original_owner);
+ .capture_target_page_residence_token_for_session(None)
+ .expect("the original Page should expose its attachment lifetime");
ctx.install_navigation_fixture_for_session_owner(
"data:text/html,<body>replacement-after-ack</body>",
None,
@@ -385,7 +385,7 @@ async fn completed_renderer_ack_wins_when_page_replacement_is_already_observable
let outcome = wait_for_renderer_input_or_page_replacement(
std::future::ready("renderer-ack"),
- Some(observer),
+ Some(page_residence_token),
)
.await;
assert!(matches!(
diff --git a/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p0_input.rs b/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p0_input.rs
index 149b059cd..e9e95da42 100644
--- a/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p0_input.rs
+++ b/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p0_input.rs
@@ -3,7 +3,11 @@ use super::super::*;
use super::support::CdpPageHarness;
use crate::conn::CdpCommandTaskStep;
use serde_json::json;
-use std::time::Duration;
+use std::{
+ future::Future,
+ task::{Context, Poll, Waker},
+ time::Duration,
+};
async fn expect_page_replacement_cleans_up_pending_input_ack(
ctx: &mut TestContext,
@@ -17,6 +21,12 @@ async fn expect_page_replacement_cleans_up_pending_input_ack(
.conn
.target_page_residence_identity_for_session(Some(&page.session_id))
.expect("the input command should have a Page owner");
+ let original_attachment = ctx
+ .conn
+ .runtime_session_owner_slot(Some(&page.session_id))
+ .expect("the input command should route to a Page slot")
+ .page_attachment_id()
+ .expect("the input command should have a concrete Page attachment");
let raw = json!({
"id": command_id,
"method": method,
@@ -37,10 +47,9 @@ async fn expect_page_replacement_cleans_up_pending_input_ack(
);
let mut completion = Box::pin(pending.wait());
+ let mut poll_context = Context::from_waker(Waker::noop());
assert!(
- tokio::time::timeout(Duration::from_millis(25), &mut completion)
- .await
- .is_err(),
+ matches!(completion.as_mut().poll(&mut poll_context), Poll::Pending),
"{method} must not reply before either its renderer ACK or Page replacement"
);
@@ -53,7 +62,14 @@ async fn expect_page_replacement_cleans_up_pending_input_ack(
.conn
.target_page_residence_identity_for_session(Some(&page.session_id))
.expect("the replacement should install a Page owner");
+ let replacement_attachment = ctx
+ .conn
+ .runtime_session_owner_slot(Some(&page.session_id))
+ .expect("the replacement should route to a Page slot")
+ .page_attachment_id()
+ .expect("the replacement should have a concrete Page attachment");
assert_ne!(original_owner, replacement_owner);
+ assert_ne!(original_attachment, replacement_attachment);
let completed = tokio::time::timeout(Duration::from_secs(5), &mut completion)
.await