Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix: acknowledge pending input on page replacement

ldm0a9aa7a321603
diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rs
index 7c98aa6f3..49a1f1b37 100644
--- a/moli-protocol/src/conn.rs
+++ b/moli-protocol/src/conn.rs
@@ -543,7 +543,8 @@ pub(crate) use state::{
ServiceWorkerRuntimeExceptionSnapshot, ServiceWorkerTargetState, SharedWorkerTargetState,
SiteDataClearOptions, TargetIdentityState, TargetInitialEmptyDocumentCreator, TargetOwnerState,
TargetPageAttachmentId, TargetPageProtocolAttachmentIdentity, TargetPageResidenceIdentity,
- TargetPageSessionState, TargetPreparedJavaScriptDialog, TargetPreparedJavaScriptDialogRoute,
+ TargetPageResidenceObservation, TargetPageResidenceObserver, TargetPageSessionState,
+ TargetPreparedJavaScriptDialog, TargetPreparedJavaScriptDialogRoute,
TargetRootDocumentProtocolAttachmentIdentity, TargetRuntimeSlot,
TargetServiceWorkerProtocolAttachmentIdentity, TargetServiceWorkerProtocolAttachmentRetirement,
TargetServiceWorkerRunIdentity, TargetServiceWorkerRunRetirement,
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 b8b91b2a0..f5406b21d 100644
--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs
+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs
@@ -3021,6 +3021,26 @@ impl CdpConnection {
== Some(expected)
}
+ /// Observes replacement of the exact installed Page that admitted work.
+ pub(crate) fn register_target_page_residence_observer_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())
+ }
+
/// Captures the exact protocol attachment currently addressing a Page.
pub(crate) fn target_page_protocol_attachment_identity_for_session(
&self,
diff --git a/moli-protocol/src/conn/state/mod.rs b/moli-protocol/src/conn/state/mod.rs
index cbb71bb26..e246970a4 100644
--- a/moli-protocol/src/conn/state/mod.rs
+++ b/moli-protocol/src/conn/state/mod.rs
@@ -12,6 +12,7 @@ mod inspector;
mod javascript_dialog;
mod navigation;
mod navigation_outcome;
+mod page_residence_observer;
mod page_resource;
mod page_slot;
mod parking;
@@ -56,6 +57,9 @@ pub(crate) use devtools_session::{
pub(crate) use document_lifecycle_observer::{
RendererDocumentLifecycleObservation, RendererDocumentLifecycleObserver,
};
+pub(crate) use page_residence_observer::{
+ TargetPageResidenceObservation, TargetPageResidenceObserver,
+};
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
new file mode 100644
index 000000000..bb271b4c9
--- /dev/null
+++ b/moli-protocol/src/conn/state/page_residence_observer.rs
@@ -0,0 +1,94 @@
+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_slot.rs b/moli-protocol/src/conn/state/page_slot.rs
index bd9c8cd7e..1bd4cfc60 100644
--- a/moli-protocol/src/conn/state/page_slot.rs
+++ b/moli-protocol/src/conn/state/page_slot.rs
@@ -14,6 +14,7 @@ use super::document_lifecycle_observer::{
RendererDocumentLifecycleObservation, RendererDocumentLifecycleObservationPublisher,
RendererDocumentLifecycleObserver,
};
+use super::page_residence_observer::{TargetPageResidenceObservation, TargetPageResidenceObserver};
use super::{NavigationRequestId, RendererPageResidenceIdentity, TargetPageAttachmentId};
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
@@ -332,6 +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>>,
pending_navigation_request: Option<PendingNavigationRequest>,
committed_document_navigation: Option<DocumentNavigationToken>,
renderer_document_lifecycle: RendererDocumentLifecycleProtocolState,
@@ -502,11 +504,27 @@ 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,
+ );
+ }
+ let publisher = self
+ .loaded_page_generation_publisher
+ .get_or_insert_with(|| watch::channel(self.loaded_page_generation).0);
+ TargetPageResidenceObserver::new(expected_generation, publisher.subscribe())
+ }
+
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);
+ self.publish_loaded_page_generation();
}
#[cfg(test)]
@@ -516,12 +534,20 @@ impl TargetPageSlot {
#[cfg(test)]
pub(crate) fn set_loaded_page_generation(&mut self, generation: u64) {
- if self.loaded_page_generation != generation {
- self.finish_renderer_document_lifecycle_observers(
- RendererDocumentLifecycleObservation::Superseded,
- );
+ if self.loaded_page_generation == generation {
+ return;
}
+ self.finish_renderer_document_lifecycle_observers(
+ 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)]
diff --git a/moli-protocol/src/domains/input.rs b/moli-protocol/src/domains/input.rs
index c5dd0ae1b..bbf591c66 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,
+ TargetPageResidenceIdentity, TargetPageResidenceObservation, TargetPageResidenceObserver,
};
use crate::devtools_runtime::{
DevToolsCommand, DevToolsCommandContext, DevToolsCommandResult,
@@ -61,6 +61,7 @@ pub(crate) struct PendingInputCommandDispatch {
command_id: Option<u64>,
session_id: Option<String>,
owner: TargetPageResidenceIdentity,
+ owner_observer: Option<TargetPageResidenceObserver>,
kind: PendingInputCommandKind,
pending: PendingInputOperation,
}
@@ -135,6 +136,30 @@ enum PendingInputOperation {
enum CompletedInputOperation {
Page(Box<Result<CompletedPageCommand, String>>),
+ PageResidenceSuperseded,
+ PageResidenceUnavailable,
+}
+
+enum RendererInputWaitOutcome<T> {
+ Completed(T),
+ PageResidence(TargetPageResidenceObservation),
+}
+
+async fn wait_for_renderer_input_or_page_replacement<T>(
+ completion: impl std::future::Future<Output = T>,
+ owner_observer: Option<TargetPageResidenceObserver>,
+) -> RendererInputWaitOutcome<T> {
+ let Some(owner_observer) = owner_observer else {
+ return RendererInputWaitOutcome::Completed(completion.await);
+ };
+ tokio::pin!(completion);
+ tokio::select! {
+ biased;
+ result = &mut completion => RendererInputWaitOutcome::Completed(result),
+ observation = owner_observer.wait() => {
+ RendererInputWaitOutcome::PageResidence(observation)
+ }
+ }
}
impl PendingInputCommandDispatch {
@@ -143,16 +168,32 @@ impl PendingInputCommandDispatch {
}
pub(crate) async fn wait(self) -> CompletedInputCommandDispatch {
+ let completed = match self.pending {
+ PendingInputOperation::Page(pending) => {
+ match wait_for_renderer_input_or_page_replacement(
+ pending.wait(),
+ self.owner_observer,
+ )
+ .await
+ {
+ RendererInputWaitOutcome::Completed(result) => CompletedInputOperation::Page(
+ Box::new(result.map_err(|error| error.to_string())),
+ ),
+ RendererInputWaitOutcome::PageResidence(
+ TargetPageResidenceObservation::Superseded,
+ ) => CompletedInputOperation::PageResidenceSuperseded,
+ RendererInputWaitOutcome::PageResidence(
+ TargetPageResidenceObservation::Unavailable,
+ ) => CompletedInputOperation::PageResidenceUnavailable,
+ }
+ }
+ };
CompletedInputCommandDispatch {
command_id: self.command_id,
session_id: self.session_id,
owner: self.owner,
kind: self.kind,
- completed: match self.pending {
- PendingInputOperation::Page(pending) => CompletedInputOperation::Page(Box::new(
- pending.wait().await.map_err(|error| error.to_string()),
- )),
- },
+ completed,
}
}
}
@@ -167,6 +208,15 @@ impl CompletedInputCommandDispatch {
}
}
+impl PendingInputCommandKind {
+ fn uses_renderer_host_ack_cleanup(&self) -> bool {
+ // Chromium's InputInjector owns replacement cleanup for the mouse and
+ // key callback queues. Touch, drag, and IME commands have separate
+ // completion protocols and must keep waiting for those terminals.
+ matches!(self, Self::DispatchMouseEvent | Self::DispatchKeyEvent)
+ }
+}
+
impl PendingInputCommandStartError {
fn invalid_params() -> Self {
Self {
@@ -534,21 +584,13 @@ fn start_pending_input_command(
InputAction::InsertText => {
let text = key::parse_insert_text(cmd)
.map_err(|_| PendingInputCommandStartError::invalid_params())?;
- let owner = conn
- .target_page_residence_identity_for_session(cmd.session_id)
- .ok_or_else(PendingInputCommandStartError::no_document_loaded)?;
- let page = loaded_page_mut(conn, cmd.session_id)
- .ok_or_else(PendingInputCommandStartError::no_document_loaded)?;
- Ok(Some(PendingInputCommandDispatch {
- command_id: cmd.id,
- session_id: cmd.session_id.map(str::to_owned),
- owner,
- kind: PendingInputCommandKind::InsertText,
- pending: PendingInputOperation::Page(
- page.start_insert_text_into_active_control(&text)
- .map_err(PendingInputCommandStartError::renderer_error)?,
- ),
- }))
+ start_page_input_command(
+ conn,
+ cmd.id,
+ cmd.session_id,
+ PendingInputCommandKind::InsertText,
+ |page| page.start_insert_text_into_active_control(&text),
+ )
}
InputAction::CancelDragging
| InputAction::SetIgnoreInputEvents
@@ -911,17 +953,12 @@ fn start_devtools_dispatch_key_event_command(
command_session_id: Option<&str>,
command: DevToolsDispatchKeyEventCommand,
) -> Result<Option<PendingInputCommandDispatch>, PendingInputCommandStartError> {
- let owner = conn
- .target_page_residence_identity_for_session(command_session_id)
- .ok_or_else(PendingInputCommandStartError::no_document_loaded)?;
- let page = loaded_page_mut(conn, command_session_id)
- .ok_or_else(PendingInputCommandStartError::no_document_loaded)?;
- Ok(Some(PendingInputCommandDispatch {
+ start_page_input_command(
+ conn,
command_id,
- session_id: command_session_id.map(str::to_owned),
- owner,
- kind: PendingInputCommandKind::DispatchKeyEvent,
- pending: PendingInputOperation::Page(
+ command_session_id,
+ PendingInputCommandKind::DispatchKeyEvent,
+ |page| {
page.start_dispatch_key_event_with_outcome(
key::devtools_key_event_dom_event_name(command.event_type),
&command.key,
@@ -931,9 +968,8 @@ fn start_devtools_dispatch_key_event_command(
command.auto_repeat,
command.should_insert_text,
)
- .map_err(PendingInputCommandStartError::renderer_error)?,
- ),
- }))
+ },
+ )
}
fn start_page_input_command(
@@ -949,10 +985,14 @@ fn start_page_input_command(
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,
kind,
pending: PendingInputOperation::Page(pending),
}))
@@ -1231,7 +1271,27 @@ async fn complete_pending_input_command(
) -> CompletedInputCommandResult {
let session_id = completed.session_id.as_deref();
let owner = completed.owner;
- let completed_operation = completed.completed;
+ let completed_operation = match completed.completed {
+ CompletedInputOperation::Page(completed) => completed,
+ CompletedInputOperation::PageResidenceSuperseded => {
+ // Match InputInjector::Cleanup(): replacement of the widget/Page
+ // retires an outstanding mouse/key ACK as protocol success even
+ // when the old renderer never publishes its normal completion.
+ return CompletedInputCommandResult {
+ result: Ok(DevToolsCommandResult::Empty),
+ protocol_events: Vec::new(),
+ };
+ }
+ CompletedInputOperation::PageResidenceUnavailable => {
+ return CompletedInputCommandResult {
+ result: Err(DevToolsError::new(
+ DevToolsErrorKind::Internal,
+ "input command Page residence became unavailable",
+ )),
+ protocol_events: Vec::new(),
+ };
+ }
+ };
let mut side_effects = InputCommandSideEffects::default();
let result = match completed.kind {
@@ -1402,13 +1462,11 @@ pub(crate) async fn complete_pending_input_command_output_plan(
}
fn completed_page_command_result(
- completed: CompletedInputOperation,
+ completed: Box<Result<CompletedPageCommand, String>>,
) -> Result<CompletedPageCommand, DevToolsError> {
- match completed {
- CompletedInputOperation::Page(result) => match *result {
- Ok(completion) => Ok(completion),
- Err(error) => Err(DevToolsError::new(DevToolsErrorKind::Internal, error)),
- },
+ match *completed {
+ Ok(completion) => Ok(completion),
+ Err(error) => Err(DevToolsError::new(DevToolsErrorKind::Internal, error)),
}
}
diff --git a/moli-protocol/src/domains/input/tests.rs b/moli-protocol/src/domains/input/tests.rs
index 12b77be79..689f72347 100644
--- a/moli-protocol/src/domains/input/tests.rs
+++ b/moli-protocol/src/domains/input/tests.rs
@@ -288,6 +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,
kind: PendingInputCommandKind::DispatchMouseEvent,
pending: PendingInputOperation::Page(pending),
}
@@ -321,6 +322,49 @@ async fn completed_mouse_event_does_not_restore_replaced_page_state() {
);
}
+#[tokio::test(flavor = "multi_thread")]
+async fn pending_mouse_event_acknowledges_when_page_is_replaced_before_renderer_completion() {
+ 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
+ .conn
+ .register_target_page_residence_observer_for_session(None, &original_owner);
+
+ 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 outcome = tokio::time::timeout(std::time::Duration::from_secs(1), wait)
+ .await
+ .expect("Page replacement should settle the pending input wait");
+ assert!(matches!(
+ outcome,
+ RendererInputWaitOutcome::PageResidence(TargetPageResidenceObservation::Superseded)
+ ));
+
+ let completed = complete_pending_input_command(
+ &mut ctx.conn,
+ CompletedInputCommandDispatch {
+ command_id: Some(105),
+ session_id: None,
+ owner: original_owner,
+ kind: PendingInputCommandKind::DispatchMouseEvent,
+ completed: CompletedInputOperation::PageResidenceSuperseded,
+ },
+ &mut CommandDispatchContext::default(),
+ )
+ .await;
+ assert!(matches!(completed.result, Ok(DevToolsCommandResult::Empty)));
+ assert!(completed.protocol_events.is_empty());
+}
+
#[tokio::test(flavor = "multi_thread")]
async fn coordinate_mouse_event_without_document_still_reports_no_document_loaded() {
let mut ctx = TestContext::new();