Skip to content

armgit / moli

Public Imported from GitHub
0

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

bind classic DOM references to exact page residence

ldm040b1d0ce02b6
diff --git a/moli-protocol-server/src/cdp_scheduler.rs b/moli-protocol-server/src/cdp_scheduler.rs
index c2c8b4537..f6418d220 100644
--- a/moli-protocol-server/src/cdp_scheduler.rs
+++ b/moli-protocol-server/src/cdp_scheduler.rs
@@ -15,10 +15,11 @@ use moli_protocol::{
CdpTargetHostLifecycleObserver, CommandDispatchContext, CompletedCdpCommandDispatch,
CompletedDeferredMainDocumentLoadCompletion, DeferredMainDocumentLoadCompletionOutputAction,
DeferredMainDocumentLoadCompletionOutputInterest, DeferredMainDocumentLoadObservationId,
- DeferredMainDocumentLoadPredecessorCandidate, PageScreencastCaptureCompletion,
- PageScreencastCaptureStart, PageScreencastRegistration, PageScreencastSubscriptionStatus,
- ParsedCdpCommand, PendingCdpCommandDispatch, PendingDeferredMainDocumentLoadCompletion,
- PendingPageScreencastCapture, ProtocolSchedulerWorkKind, RuntimeCommandOutputBarriers,
+ DeferredMainDocumentLoadPredecessorCandidate, DevToolsPageResidenceIdentity,
+ PageScreencastCaptureCompletion, PageScreencastCaptureStart, PageScreencastRegistration,
+ PageScreencastSubscriptionStatus, ParsedCdpCommand, PendingCdpCommandDispatch,
+ PendingDeferredMainDocumentLoadCompletion, PendingPageScreencastCapture,
+ ProtocolSchedulerWorkKind, RuntimeCommandOutputBarriers,
conn::{RuntimeInspectorResponseReady, RuntimeInspectorResponseReadySender},
devtools_runtime::{
DevToolsCommand, DevToolsCommandResult, DevToolsError, DevToolsNavigationWait,
@@ -86,6 +87,11 @@ pub(crate) struct DevToolsCommandExecution {
pub(crate) protocol_output: ProtocolOutputSequence,
}
+pub(crate) struct DevToolsPageCommandExecution {
+ pub(crate) execution: DevToolsCommandExecution,
+ pub(crate) page_residence: Option<DevToolsPageResidenceIdentity>,
+}
+
// `Dispatch` is the common, short-lived command-start result. Boxing it only
// to match the rare no-payload variant would add one allocation to every
// dispatched protocol command; the bounded stack value is intentional.
@@ -107,6 +113,16 @@ pub(crate) struct CdpScheduler {
page_screencasts: HashMap<Option<String>, PageScreencastSchedule>,
}
+impl CdpScheduler {
+ pub(crate) fn page_residence_identity_for_devtools_context(
+ &mut self,
+ context: &moli_protocol::devtools_runtime::DevToolsCommandContext,
+ ) -> Option<DevToolsPageResidenceIdentity> {
+ self.conn
+ .page_residence_identity_for_devtools_context(context)
+ }
+}
+
#[derive(Debug)]
struct PendingNavigationBackgroundEvent {
target_id: Option<String>,
@@ -1012,9 +1028,10 @@ impl CdpScheduler {
command: DevToolsCommand,
) -> DevToolsCommandExecution {
self.execute_devtools_command_with_external_load_wait_and_protocol_messages_inner(
- receivers, command, None, None,
+ receivers, command, None, None, None,
)
.await
+ .execution
}
pub(crate) async fn execute_devtools_command_with_external_load_wait_and_protocol_messages_background_command_id(
@@ -1028,21 +1045,25 @@ impl CdpScheduler {
command,
None,
background_command_id,
+ None,
)
.await
+ .execution
}
- pub(crate) async fn execute_devtools_command_with_external_load_wait_and_protocol_messages_timeout(
+ pub(crate) async fn execute_devtools_command_with_external_load_wait_and_page_residence(
&mut self,
receivers: &mut CdpSchedulerEventReceivers,
command: DevToolsCommand,
- timeout: std::time::Duration,
- ) -> DevToolsCommandExecution {
+ timeout: Option<std::time::Duration>,
+ expected_page: Option<&DevToolsPageResidenceIdentity>,
+ ) -> DevToolsPageCommandExecution {
self.execute_devtools_command_with_external_load_wait_and_protocol_messages_inner(
receivers,
command,
- Some(timeout),
+ timeout,
None,
+ expected_page,
)
.await
}
@@ -1053,7 +1074,8 @@ impl CdpScheduler {
command: DevToolsCommand,
timeout: Option<std::time::Duration>,
background_command_id: Option<u64>,
- ) -> DevToolsCommandExecution {
+ expected_page: Option<&DevToolsPageResidenceIdentity>,
+ ) -> DevToolsPageCommandExecution {
let navigation_wait = devtools_navigation_wait(&command);
let navigation_lifecycle_milestone =
devtools_navigation_lifecycle_milestone(navigation_wait);
@@ -1074,12 +1096,32 @@ impl CdpScheduler {
Ok(output) => output,
Err(failure) => {
let (protocol_output, error) = failure.into_parts();
- return DevToolsCommandExecution {
- result: Err(error),
- protocol_output,
+ return DevToolsPageCommandExecution {
+ execution: DevToolsCommandExecution {
+ result: Err(error),
+ protocol_output,
+ },
+ page_residence: None,
};
}
};
+ // Background navigation completion is deliberately drained before a
+ // command starts. Capture and authorize the Page only after that
+ // drain, so a DOM reference cannot pass a pre-drain check and then be
+ // dispatched to the replacement Page.
+ let page_residence = self.page_residence_identity_for_devtools_context(&navigation_context);
+ if expected_page.is_some_and(|expected| page_residence.as_ref() != Some(expected)) {
+ return DevToolsPageCommandExecution {
+ execution: DevToolsCommandExecution {
+ result: Err(DevToolsError::new(
+ moli_protocol::devtools_runtime::DevToolsErrorKind::NoSuchNode,
+ "DOM reference belongs to a replaced Page",
+ )),
+ protocol_output,
+ },
+ page_residence,
+ };
+ }
let navigation_command_output_start = protocol_output.len();
let mut execution =
if runtime_dispatch::devtools_command_uses_interleaved_runtime_dispatch(&command) {
@@ -1278,7 +1320,10 @@ impl CdpScheduler {
execution
.protocol_output
.append(foreground_navigation_network_barrier.finish());
- execution
+ DevToolsPageCommandExecution {
+ execution,
+ page_residence,
+ }
}
async fn drain_inflight_background_navigation_before_internal_command(
diff --git a/moli-protocol-server/src/protocol_server/tests/bidi.rs b/moli-protocol-server/src/protocol_server/tests/bidi.rs
index 99e6757e6..6054051d0 100644
--- a/moli-protocol-server/src/protocol_server/tests/bidi.rs
+++ b/moli-protocol-server/src/protocol_server/tests/bidi.rs
@@ -369,6 +369,71 @@ async fn websocket_bidi_existing_classic_session_shares_classic_runtime_context(
protocol_server.abort();
}
+#[tokio::test]
+async fn websocket_bidi_navigation_stales_classic_element_from_replaced_page() {
+ let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
+ let session_id = classic_new_session_on_server(cdp_addr).await;
+ let first_url =
+ classic_data_url_for_bidi_test("<!doctype html><main id='target'>first Page</main>");
+ let second_url =
+ classic_data_url_for_bidi_test("<!doctype html><main id='target'>second Page</main>");
+ let navigated = classic_request_on_server_with_body(
+ cdp_addr,
+ "POST",
+ &format!("/session/{session_id}/url"),
+ json!({ "url": first_url }),
+ )
+ .await;
+ assert_eq!(navigated, json!({ "value": null }));
+ let element = classic_request_on_server_with_body(
+ cdp_addr,
+ "POST",
+ &format!("/session/{session_id}/element"),
+ json!({ "using": "css selector", "value": "#target" }),
+ )
+ .await;
+ let element_id = element["value"]["element-6066-11e4-a52e-4f735466cecf"]
+ .as_str()
+ .expect("Classic element id")
+ .to_owned();
+
+ let mut socket = connect_classic_session_bidi_socket(cdp_addr, &session_id).await;
+ let tree = send_bidi_command(&mut socket, 1, "browsingContext.getTree", json!({})).await;
+ let context_id = tree["result"]["contexts"][0]["context"]
+ .as_str()
+ .expect("attached Classic context id")
+ .to_owned();
+ let bidi_navigation = send_bidi_command(
+ &mut socket,
+ 2,
+ "browsingContext.navigate",
+ json!({
+ "context": context_id,
+ "url": second_url,
+ "wait": "complete"
+ }),
+ )
+ .await;
+ assert_eq!(
+ bidi_navigation["type"],
+ json!("success"),
+ "attached BiDi navigation should replace the Classic-owned Page: {bidi_navigation:?}"
+ );
+
+ let (status, stale) = classic_request_status_on_server_with_body(
+ cdp_addr,
+ "GET",
+ &format!("/session/{session_id}/element/{element_id}/text"),
+ json!({}),
+ )
+ .await;
+ assert_eq!(status, 404);
+ assert_eq!(stale["value"]["error"], json!("stale element reference"));
+
+ let _ = socket.close(None).await;
+ protocol_server.abort();
+}
+
#[tokio::test]
async fn websocket_bidi_attached_classic_session_title_waits_for_script_triggered_form_navigation()
{
@@ -19574,6 +19639,46 @@ async fn classic_request_on_server_with_body(
serde_json::from_str(body).expect("Classic response json")
}
+async fn classic_request_status_on_server_with_body(
+ addr: std::net::SocketAddr,
+ method: &str,
+ path: &str,
+ body: serde_json::Value,
+) -> (u16, serde_json::Value) {
+ let mut stream = tokio::net::TcpStream::connect(addr)
+ .await
+ .expect("connect to Classic HTTP server");
+ let body = body.to_string();
+ let request = format!(
+ "{method} {path} HTTP/1.1\r\nHost: {addr}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
+ body.len()
+ );
+ stream
+ .write_all(request.as_bytes())
+ .await
+ .expect("write Classic request");
+ let mut response = Vec::new();
+ stream
+ .read_to_end(&mut response)
+ .await
+ .expect("read Classic response");
+ let response = String::from_utf8(response).expect("Classic response utf-8");
+ let status = response
+ .lines()
+ .next()
+ .and_then(|line| line.split_whitespace().nth(1))
+ .and_then(|status| status.parse::<u16>().ok())
+ .expect("Classic HTTP status");
+ let body = response
+ .split_once("\r\n\r\n")
+ .map(|(_, body)| body)
+ .expect("Classic response body");
+ (
+ status,
+ serde_json::from_str(body).expect("Classic response json"),
+ )
+}
+
fn classic_data_url_for_bidi_test(html: &str) -> String {
fn push_hex(encoded: &mut String, byte: u8) {
const HEX: &[u8; 16] = b"0123456789ABCDEF";
diff --git a/moli-protocol-server/src/protocol_server/tests/classic.rs b/moli-protocol-server/src/protocol_server/tests/classic.rs
index ef96607b1..6768d32b0 100644
--- a/moli-protocol-server/src/protocol_server/tests/classic.rs
+++ b/moli-protocol-server/src/protocol_server/tests/classic.rs
@@ -1163,8 +1163,12 @@ async fn webdriver_classic_element_reference_owner_rejects_forged_and_stales_aft
.as_str()
.expect("classic session id");
- let first_url = classic_data_url("<body><main id='target'>first</main></body>");
- let second_url = classic_data_url("<body><main id='target'>second</main></body>");
+ let second_url = classic_data_url(
+ "<body><a id='navigate' href='#'>navigate</a><main id='target'>second</main></body>",
+ );
+ let first_url = classic_data_url(&format!(
+ "<body><a id='navigate' href='{second_url}'>navigate</a><main id='target'>first</main></body>"
+ ));
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
@@ -1202,13 +1206,14 @@ async fn webdriver_classic_element_reference_owner_rejects_forged_and_stales_aft
assert_eq!(forged_owner_status, StatusCode::NOT_FOUND);
assert_eq!(forged_owner["value"]["error"], json!("no such element"));
- let _ = classic_request_json_with_body(
+ let navigate_link_id = classic_find_css_element_id(app.clone(), session_id, "#navigate").await;
+ let clicked = classic_request_json(
app.clone(),
Method::POST,
- &format!("/session/{session_id}/url"),
- json!({ "url": second_url }),
+ &format!("/session/{session_id}/element/{navigate_link_id}/click"),
)
.await;
+ assert_eq!(clicked, json!({ "value": null }));
let (stale_status, stale) = classic_request_status_and_json(
app.clone(),
Method::GET,
diff --git a/moli-protocol-server/src/protocol_server/webdriver_classic.rs b/moli-protocol-server/src/protocol_server/webdriver_classic.rs
index 95dfe87d4..ba7ed13ac 100644
--- a/moli-protocol-server/src/protocol_server/webdriver_classic.rs
+++ b/moli-protocol-server/src/protocol_server/webdriver_classic.rs
@@ -13,6 +13,7 @@ use axum::{
};
use moli_core::page::RendererDocumentLifecycleMilestone;
use moli_protocol::{
+ DevToolsPageResidenceIdentity,
devtools_runtime::{
DevToolsCommand, DevToolsCommandContext, DevToolsCommandResult, DevToolsDomGeometryResult,
DevToolsDomNodeReference, DevToolsDownloadBehaviorSetting, DevToolsError,
@@ -98,7 +99,7 @@ use script_refs::{
collect_classic_script_frame_reference_owner_keys,
};
pub(super) use state::SharedClassicSessionRegistry;
-use state::{ClassicSessionBinding, ClassicSessionRuntimeHandle};
+use state::{ClassicPageBoundDomReference, ClassicSessionBinding, ClassicSessionRuntimeHandle};
pub(super) use window::{
webdriver_classic_close_window, webdriver_classic_fullscreen_window,
webdriver_classic_get_window, webdriver_classic_get_window_handles,
@@ -291,10 +292,11 @@ async fn ensure_classic_current_browsing_context_exists(
ensure_classic_browsing_context_exists(binding, Some(frame_id)).await
}
-fn classic_note_top_level_document_change(state: &AppState, session_id: &str, target_id: &str) {
- let mut registry = state.classic_session_registry.lock();
- registry.bump_document_generation(session_id, target_id);
- registry.set_current_frame_id(session_id, None);
+fn classic_reset_to_top_level_browsing_context(state: &AppState, session_id: &str) {
+ state
+ .classic_session_registry
+ .lock()
+ .set_current_frame_id(session_id, None);
}
async fn ensure_classic_top_level_browsing_context_exists(
@@ -407,19 +409,28 @@ fn classic_element_reference_from_id(element_id: String) -> Value {
fn registered_classic_element_reference_from_dom_reference(
state: &AppState,
binding: &ClassicSessionBinding,
+ page_residence: &DevToolsPageResidenceIdentity,
node_id: u32,
reference: DevToolsDomNodeReference,
) -> Value {
let element_id = state
.classic_session_registry
.lock()
- .register_element_reference(binding, node_id, reference);
+ .register_element_reference(
+ binding,
+ node_id,
+ ClassicPageBoundDomReference {
+ page_residence: page_residence.clone(),
+ reference,
+ },
+ );
classic_element_reference_from_id(element_id)
}
fn registered_classic_element_references_from_canonical_references(
state: &AppState,
binding: &ClassicSessionBinding,
+ page_residence: &DevToolsPageResidenceIdentity,
references: impl IntoIterator<Item = ClassicScriptCanonicalNodeReference>,
) -> Vec<Value> {
references
@@ -428,6 +439,7 @@ fn registered_classic_element_references_from_canonical_references(
registered_classic_element_reference_from_dom_reference(
state,
binding,
+ page_residence,
reference.node_id,
reference.reference,
)
@@ -438,13 +450,21 @@ fn registered_classic_element_references_from_canonical_references(
fn registered_classic_shadow_root_reference_from_dom_reference(
state: &AppState,
binding: &ClassicSessionBinding,
+ page_residence: &DevToolsPageResidenceIdentity,
node_id: u32,
reference: DevToolsDomNodeReference,
) -> Value {
let shadow_root_id = state
.classic_session_registry
.lock()
- .register_shadow_root_reference(binding, node_id, reference);
+ .register_shadow_root_reference(
+ binding,
+ node_id,
+ ClassicPageBoundDomReference {
+ page_residence: page_residence.clone(),
+ reference,
+ },
+ );
classic_shadow_root_reference(shadow_root_id)
}
@@ -460,17 +480,27 @@ fn classic_frame_reference(frame_id: impl Into<String>) -> Value {
})
}
-async fn release_classic_remote_object(
+#[derive(Debug)]
+struct ClassicPageBoundRemoteObject {
+ page_residence: DevToolsPageResidenceIdentity,
+ object_id: String,
+}
+
+async fn release_classic_page_bound_remote_object(
binding: &ClassicSessionBinding,
context: &ClassicDevToolsCommandContext,
- object_id: impl Into<String>,
+ remote_object: ClassicPageBoundRemoteObject,
label: &str,
) {
- let object_id = object_id.into();
- if let Err(error) = binding
+ let result = binding
.runtime
- .execute(release_remote_object_command(context, object_id))
- .await
+ .execute_on_page(
+ release_remote_object_command(context, remote_object.object_id),
+ remote_object.page_residence,
+ )
+ .await;
+ if let Err(error) = result
+ && error.kind != DevToolsErrorKind::NoSuchNode
{
warn!(
?error,
@@ -483,6 +513,7 @@ async fn release_classic_remote_handle(
binding: &ClassicSessionBinding,
context: &ClassicDevToolsCommandContext,
value: &DevToolsRemoteValue,
+ page_residence: &DevToolsPageResidenceIdentity,
label: &str,
) {
let object_id = value
@@ -491,30 +522,51 @@ async fn release_classic_remote_handle(
.or(value.shared_id.as_ref())
.map(|handle| handle.as_str().to_owned());
if let Some(object_id) = object_id {
- release_classic_remote_object(binding, context, object_id, label).await;
+ release_classic_page_bound_remote_object(
+ binding,
+ context,
+ ClassicPageBoundRemoteObject {
+ page_residence: page_residence.clone(),
+ object_id,
+ },
+ label,
+ )
+ .await;
}
}
async fn resolve_classic_element_remote_object_from_reference(
binding: &ClassicSessionBinding,
context: &ClassicDevToolsCommandContext,
- reference: DevToolsDomNodeReference,
+ reference: ClassicPageBoundDomReference,
execution_context_id: Option<i64>,
object_group: &str,
label: &str,
-) -> Result<String, ClassicError> {
+) -> Result<ClassicPageBoundRemoteObject, ClassicError> {
+ let ClassicPageBoundDomReference {
+ page_residence,
+ reference,
+ } = reference;
let resolve = resolve_element_reference_command_with_execution_context(
context,
reference,
execution_context_id,
object_group,
);
- match binding.runtime.execute(resolve).await {
+ match binding
+ .runtime
+ .execute_on_page(resolve, page_residence.clone())
+ .await
+ {
Ok(DevToolsCommandResult::ResolveNode(result)) => result
.object
.get("objectId")
.and_then(Value::as_str)
.map(ToOwned::to_owned)
+ .map(|object_id| ClassicPageBoundRemoteObject {
+ page_residence,
+ object_id,
+ })
.ok_or_else(|| {
ClassicError::new(
ClassicErrorCode::StaleElementReference,
@@ -542,7 +594,7 @@ async fn resolve_classic_remote_object(
element_id: &str,
object_group: &str,
label: &str,
-) -> Result<String, ClassicError> {
+) -> Result<ClassicPageBoundRemoteObject, ClassicError> {
let reference = resolve_classic_element_dom_reference(state, binding, element_id)?;
resolve_classic_element_remote_object_from_reference(
binding,
@@ -558,23 +610,35 @@ async fn resolve_classic_remote_object(
async fn resolve_classic_shadow_root_remote_object_from_reference(
binding: &ClassicSessionBinding,
context: &ClassicDevToolsCommandContext,
- reference: DevToolsDomNodeReference,
+ reference: ClassicPageBoundDomReference,
execution_context_id: Option<i64>,
object_group: &str,
label: &str,
-) -> Result<String, ClassicError> {
+) -> Result<ClassicPageBoundRemoteObject, ClassicError> {
+ let ClassicPageBoundDomReference {
+ page_residence,
+ reference,
+ } = reference;
let resolve = resolve_shadow_root_reference_command_with_execution_context(
context,
reference,
execution_context_id,
object_group,
);
- match binding.runtime.execute(resolve).await {
+ match binding
+ .runtime
+ .execute_on_page(resolve, page_residence.clone())
+ .await
+ {
Ok(DevToolsCommandResult::ResolveNode(result)) => result
.object
.get("objectId")
.and_then(Value::as_str)
.map(ToOwned::to_owned)
+ .map(|object_id| ClassicPageBoundRemoteObject {
+ page_residence,
+ object_id,
+ })
.ok_or_else(|| {
ClassicError::new(
ClassicErrorCode::DetachedShadowRoot,
@@ -595,7 +659,7 @@ async fn resolve_classic_shadow_root_remote_object_from_reference(
async fn classic_frame_owner_dom_reference(
binding: &ClassicSessionBinding,
frame_id: &str,
-) -> Result<DevToolsDomNodeReference, ClassicError> {
+) -> Result<ClassicPageBoundDomReference, ClassicError> {
let context = DevToolsCommandContext {
protocol: DevToolsProtocol::WebDriverClassic,
session_id: Some(DevToolsSessionId::from(binding.session_id.as_str())),
@@ -604,7 +668,7 @@ async fn classic_frame_owner_dom_reference(
};
match binding
.runtime
- .execute(DevToolsCommand::GetFrameOwner(
+ .execute_with_page_residence(DevToolsCommand::GetFrameOwner(
DevToolsGetFrameOwnerCommand {
context,
frame_id: DevToolsFrameId::from(frame_id),
@@ -612,8 +676,11 @@ async fn classic_frame_owner_dom_reference(
))
.await
{
- Ok(DevToolsCommandResult::GetFrameOwner(owner)) => {
- Ok(classic_dom_reference_from_frame_owner_result(owner))
+ Ok((DevToolsCommandResult::GetFrameOwner(owner), page_residence)) => {
+ Ok(ClassicPageBoundDomReference {
+ page_residence,
+ reference: classic_dom_reference_from_frame_owner_result(owner),
+ })
}
Ok(_) => Err(ClassicError::new(
ClassicErrorCode::UnknownError,
@@ -648,6 +715,7 @@ fn classic_dom_reference_from_frame_owner_result(
async fn classic_default_execution_context_id(
binding: &ClassicSessionBinding,
context: &ClassicDevToolsCommandContext,
+ page_residence: &DevToolsPageResidenceIdentity,
label: &str,
) -> Result<i64, ClassicError> {
let command = DevToolsCommand::GetRealms(DevToolsGetRealmsCommand {
@@ -659,7 +727,11 @@ async fn classic_default_execution_context_id(
},
realm_type: Some("window".to_owned()),
});
- match binding.runtime.execute(command).await {
+ match binding
+ .runtime
+ .execute_on_page(command, page_residence.clone())
+ .await
+ {
Ok(DevToolsCommandResult::Realms(result)) => result
.realms
.iter()
@@ -688,17 +760,18 @@ async fn classic_default_execution_context_id(
async fn release_classic_remote_objects(
binding: &ClassicSessionBinding,
context: &ClassicDevToolsCommandContext,
- object_ids: Vec<String>,
+ remote_objects: Vec<ClassicPageBoundRemoteObject>,
label: &str,
) {
- for object_id in object_ids {
- release_classic_remote_object(binding, context, object_id, label).await;
+ for remote_object in remote_objects {
+ release_classic_page_bound_remote_object(binding, context, remote_object, label).await;
}
}
struct ClassicScriptArgumentHandles {
descriptors: Vec<Value>,
- remote_handles: Vec<String>,
+ remote_handles: Vec<ClassicPageBoundRemoteObject>,
+ page_residence: Option<DevToolsPageResidenceIdentity>,
}
enum ClassicScriptArgumentReference<'a> {
@@ -708,6 +781,24 @@ enum ClassicScriptArgumentReference<'a> {
Window(&'a str),
}
+enum ClassicResolvedScriptArgumentReference {
+ Element(ClassicPageBoundDomReference),
+ ShadowRoot(ClassicPageBoundDomReference),
+ Frame(ClassicPageBoundDomReference),
+ Window,
+}
+
+impl ClassicResolvedScriptArgumentReference {
+ fn page_residence(&self) -> Option<&DevToolsPageResidenceIdentity> {
+ match self {
+ Self::Element(reference) | Self::ShadowRoot(reference) | Self::Frame(reference) => {
+ Some(&reference.page_residence)
+ }
+ Self::Window => None,
+ }
+ }
+}
+
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum ClassicElementLiveIdentity {
BackendNodeId(u32),
@@ -723,30 +814,77 @@ async fn prepare_classic_script_argument_handles(
) -> Result<ClassicScriptArgumentHandles, ClassicError> {
let descriptors = classic_script_argument_descriptors(params)?;
let references = classic_script_argument_references(&descriptors)?;
- let script_execution_context_id = if references.iter().any(|reference| {
+ let mut resolved_references = Vec::with_capacity(references.len());
+ for reference in references {
+ let reference = match reference {
+ ClassicScriptArgumentReference::Element(element_id) => {
+ ClassicResolvedScriptArgumentReference::Element(
+ resolve_classic_element_dom_reference(state, binding, element_id)?,
+ )
+ }
+ ClassicScriptArgumentReference::ShadowRoot(shadow_root_id) => {
+ ClassicResolvedScriptArgumentReference::ShadowRoot(
+ resolve_classic_shadow_root_dom_reference(state, binding, shadow_root_id)?,
+ )
+ }
+ ClassicScriptArgumentReference::Frame(frame_id) => {
+ ClassicResolvedScriptArgumentReference::Frame(
+ classic_frame_owner_dom_reference(binding, frame_id).await?,
+ )
+ }
+ ClassicScriptArgumentReference::Window(window_id) => {
+ if window_id != binding.browsing_context_target_id() {
+ return Err(ClassicError::new(
+ ClassicErrorCode::NoSuchWindow,
+ "window with such id was not found",
+ ));
+ }
+ ClassicResolvedScriptArgumentReference::Window
+ }
+ };
+ resolved_references.push(reference);
+ }
+ let mut page_residence = None;
+ for reference in &resolved_references {
+ let Some(reference_page) = reference.page_residence() else {
+ continue;
+ };
+ if page_residence
+ .as_ref()
+ .is_some_and(|expected_page| expected_page != reference_page)
+ {
+ return Err(ClassicError::new(
+ ClassicErrorCode::StaleElementReference,
+ "script argument references belong to different Pages",
+ ));
+ }
+ page_residence.get_or_insert_with(|| reference_page.clone());
+ }
+ let script_execution_context_id = if resolved_references.iter().any(|reference| {
matches!(
reference,
- ClassicScriptArgumentReference::Element(_)
- | ClassicScriptArgumentReference::ShadowRoot(_)
+ ClassicResolvedScriptArgumentReference::Element(_)
+ | ClassicResolvedScriptArgumentReference::ShadowRoot(_)
)
}) {
- Some(classic_default_execution_context_id(binding, context, label).await?)
+ Some(
+ classic_default_execution_context_id(
+ binding,
+ context,
+ page_residence
+ .as_ref()
+ .expect("DOM script argument must identify its Page"),
+ label,
+ )
+ .await?,
+ )
} else {
None
};
let mut remote_handles = Vec::new();
- for reference in references {
+ for reference in resolved_references {
let object_id = match reference {
- ClassicScriptArgumentReference::Element(element_id) => {
- let reference =
- match resolve_classic_element_dom_reference(state, binding, element_id) {
- Ok(reference) => reference,
- Err(error) => {
- release_classic_remote_objects(binding, context, remote_handles, label)
- .await;
- return Err(error);
- }
- };
+ ClassicResolvedScriptArgumentReference::Element(reference) => {
resolve_classic_element_remote_object_from_reference(
binding,
context,
@@ -757,17 +895,7 @@ async fn prepare_classic_script_argument_handles(
)
.await
}
- ClassicScriptArgumentReference::ShadowRoot(shadow_root_id) => {
- let reference =
- match resolve_classic_shadow_root_dom_reference(state, binding, shadow_root_id)
- {
- Ok(reference) => reference,
- Err(error) => {
- release_classic_remote_objects(binding, context, remote_handles, label)
- .await;
- return Err(error);
- }
- };
+ ClassicResolvedScriptArgumentReference::ShadowRoot(reference) => {
match resolve_classic_shadow_root_remote_object_from_reference(
binding,
context,
@@ -778,32 +906,32 @@ async fn prepare_classic_script_argument_handles(
)
.await
{
- Ok(object_id) => {
+ Ok(remote_object) => {
if let Err(error) = verify_classic_shadow_root_remote_object_attached(
- binding, context, &object_id, label,
+ binding,
+ context,
+ &remote_object,
+ label,
)
.await
{
- release_classic_remote_object(binding, context, object_id, label).await;
+ release_classic_page_bound_remote_object(
+ binding,
+ context,
+ remote_object,
+ label,
+ )
+ .await;
release_classic_remote_objects(binding, context, remote_handles, label)
.await;
return Err(error);
}
- Ok(object_id)
+ Ok(remote_object)
}
Err(error) => Err(error),
}
}
- ClassicScriptArgumentReference::Frame(frame_id) => {
- let owner_reference =
- match classic_frame_owner_dom_reference(binding, frame_id).await {
- Ok(reference) => reference,
- Err(error) => {
- release_classic_remote_objects(binding, context, remote_handles, label)
- .await;
- return Err(error);
- }
- };
+ ClassicResolvedScriptArgumentReference::Frame(owner_reference) => {
let top_context = classic_top_level_context(binding);
resolve_classic_element_remote_object_from_reference(
binding,
@@ -815,14 +943,7 @@ async fn prepare_classic_script_argument_handles(
)
.await
}
- ClassicScriptArgumentReference::Window(window_id) => {
- if window_id != binding.browsing_context_target_id() {
- release_classic_remote_objects(binding, context, remote_handles, label).await;
- return Err(ClassicError::new(
- ClassicErrorCode::NoSuchWindow,
- "window with such id was not found",
- ));
- }
+ ClassicResolvedScriptArgumentReference::Window => {
continue;
}
};
@@ -837,6 +958,7 @@ async fn prepare_classic_script_argument_handles(
Ok(ClassicScriptArgumentHandles {
descriptors,
remote_handles,
+ page_residence,
})
}
@@ -1000,11 +1122,32 @@ fn apply_classic_script_argument_handles(
handles
.remote_handles
.iter()
- .map(|object_id| json!({ "handle": object_id })),
+ .map(|remote_object| json!({ "handle": remote_object.object_id })),
)
.collect();
}
+async fn execute_classic_script_with_argument_page(
+ binding: &ClassicSessionBinding,
+ command: DevToolsCommand,
+ timeout: Option<Duration>,
+ expected_page: Option<DevToolsPageResidenceIdentity>,
+) -> Result<(DevToolsCommandResult, DevToolsPageResidenceIdentity), DevToolsError> {
+ match expected_page {
+ Some(expected_page) => binding
+ .runtime
+ .execute_script_on_page(command, timeout, expected_page.clone())
+ .await
+ .map(|result| (result, expected_page)),
+ None => {
+ binding
+ .runtime
+ .execute_script_with_page_residence(command, timeout)
+ .await
+ }
+ }
+}
+
fn classic_script_argument_deserializer_function(user_function: String) -> String {
format!(
"function() {{\n\
@@ -1143,6 +1286,7 @@ fn classic_script_argument_deserializer_function(user_function: String) -> Strin
fn classic_script_result_value(
state: &AppState,
binding: &ClassicSessionBinding,
+ page_residence: &DevToolsPageResidenceIdentity,
value: Value,
dom_references_by_node_id: &BTreeMap<u32, ClassicScriptCanonicalNodeReference>,
frame_ids_by_owner_reference: &BTreeMap<ClassicScriptFrameOwnerReferenceKey, String>,
@@ -1155,6 +1299,7 @@ fn classic_script_result_value(
classic_script_result_value(
state,
binding,
+ page_residence,
value,
dom_references_by_node_id,
frame_ids_by_owner_reference,
@@ -1178,6 +1323,7 @@ fn classic_script_result_value(
registered_classic_element_reference_from_dom_reference(
state,
binding,
+ page_residence,
reference.node_id,
reference.reference,
)
@@ -1194,6 +1340,7 @@ fn classic_script_result_value(
registered_classic_shadow_root_reference_from_dom_reference(
state,
binding,
+ page_residence,
reference.node_id,
reference.reference,
)
@@ -1235,6 +1382,7 @@ fn classic_script_result_value(
classic_script_result_value(
state,
binding,
+ page_residence,
value,
dom_references_by_node_id,
frame_ids_by_owner_reference,
@@ -1251,15 +1399,19 @@ fn classic_script_result_value(
async fn classic_webdriver_script_result_value(
state: &AppState,
binding: &ClassicSessionBinding,
+ page_residence: &DevToolsPageResidenceIdentity,
value: Value,
) -> Result<Value, ClassicError> {
- let dom_references = classic_script_dom_references_by_node_id(binding, &value).await?;
- let frame_ids = classic_script_frame_ids_by_owner_reference(binding, &value).await?;
+ let dom_references =
+ classic_script_dom_references_by_node_id(binding, page_residence, &value).await?;
+ let frame_ids =
+ classic_script_frame_ids_by_owner_reference(binding, page_residence, &value).await?;
let popup_window_handles_by_id =
classic_popup_window_handles_by_id_for_script_result(binding, &value).await?;
classic_script_result_value(
state,
binding,
+ page_residence,
value,
&dom_references,
&frame_ids,
@@ -1269,6 +1421,7 @@ async fn classic_webdriver_script_result_value(
async fn classic_script_dom_references_by_node_id(
binding: &ClassicSessionBinding,
+ page_residence: &DevToolsPageResidenceIdentity,
value: &Value,
) -> Result<BTreeMap<u32, ClassicScriptCanonicalNodeReference>, ClassicError> {
let mut node_ids = Vec::new();
@@ -1281,7 +1434,10 @@ async fn classic_script_dom_references_by_node_id(
for node_id in node_ids {
let reference = match binding
.runtime
- .execute(describe_node_command(&context, node_id, 0, false))
+ .execute_on_page(
+ describe_node_command(&context, node_id, 0, false),
+ page_residence.clone(),
+ )
.await
{
Ok(DevToolsCommandResult::DescribeNode(result)) => {
@@ -1302,6 +1458,7 @@ async fn classic_script_dom_references_by_node_id(
async fn classic_script_frame_ids_by_owner_reference(
binding: &ClassicSessionBinding,
+ page_residence: &DevToolsPageResidenceIdentity,
value: &Value,
) -> Result<BTreeMap<ClassicScriptFrameOwnerReferenceKey, String>, ClassicError> {
let mut owner_references = Vec::new();
@@ -1311,7 +1468,8 @@ async fn classic_script_frame_ids_by_owner_reference(
let mut out = BTreeMap::new();
for owner_reference in owner_references {
let owner_dom_reference =
- classic_script_frame_owner_dom_reference(binding, owner_reference).await?;
+ classic_script_frame_owner_dom_reference(binding, page_residence, owner_reference)
+ .await?;
let frame_id = binding
.runtime
.frame_id_for_element(
@@ -1329,29 +1487,32 @@ async fn classic_script_frame_ids_by_owner_reference(
async fn classic_script_frame_owner_dom_reference(
binding: &ClassicSessionBinding,
+ page_residence: &DevToolsPageResidenceIdentity,
owner_reference: ClassicScriptFrameOwnerReferenceKey,
-) -> Result<DevToolsDomNodeReference, ClassicError> {
+) -> Result<ClassicPageBoundDomReference, ClassicError> {
if owner_reference.has_backend_node_id() {
- return Ok(owner_reference.dom_reference());
+ return Ok(ClassicPageBoundDomReference {
+ page_residence: page_residence.clone(),
+ reference: owner_reference.dom_reference(),
+ });
}
let context = classic_browsing_context(binding);
match binding
.runtime
- .execute(describe_node_command(
- &context,
- owner_reference.node_id(),
- 0,
- false,
- ))
+ .execute_on_page(
+ describe_node_command(&context, owner_reference.node_id(), 0, false),
+ page_residence.clone(),
+ )
.await
{
- Ok(DevToolsCommandResult::DescribeNode(result)) => Ok(
- classic_script_frame_owner_dom_reference_from_described_node(
+ Ok(DevToolsCommandResult::DescribeNode(result)) => Ok(ClassicPageBoundDomReference {
+ page_residence: page_residence.clone(),
+ reference: classic_script_frame_owner_dom_reference_from_described_node(
owner_reference,
&result.node,
),
- ),
+ }),
Ok(_) => Err(ClassicError::new(
ClassicErrorCode::UnknownError,
"script result frame owner lookup returned an unexpected result",
@@ -1923,7 +2084,7 @@ pub(super) async fn webdriver_classic_navigate(
};
match webdriver_classic_execute_page_load_command(&binding, command).await {
Ok(DevToolsCommandResult::Navigate(_)) => {
- classic_note_top_level_document_change(&state, &session_id, &binding.target_id);
+ classic_reset_to_top_level_browsing_context(&state, &session_id);
classic_success_into_response(Value::Null)
}
Ok(_) => classic_error_into_response(ClassicError::new(
@@ -2250,6 +2411,9 @@ pub(super) async fn webdriver_classic_switch_frame(
.await
{
Ok(frame_id) => frame_id,
+ Err(error) if error.kind == DevToolsErrorKind::NoSuchNode => {
+ return classic_error_into_response(classic_error_from_devtools_error(error));
+ }
Err(error) => return classic_error_into_response(classic_no_such_frame_error(error)),
};
Some(frame_id)
@@ -2391,7 +2555,7 @@ pub(super) async fn webdriver_classic_refresh(
.await
{
Ok(DevToolsCommandResult::Navigate(_)) => {
- classic_note_top_level_document_change(&state, &session_id, &binding.target_id);
+ classic_reset_to_top_level_browsing_context(&state, &session_id);
classic_success_into_response(Value::Null)
}
Ok(_) => classic_error_into_response(ClassicError::new(
@@ -2456,7 +2620,7 @@ async fn webdriver_classic_traverse_history(
{
Ok(DevToolsCommandResult::TraverseHistory(result)) => {
if !result.same_document {
- classic_note_top_level_document_change(&state, &session_id, &binding.target_id);
+ classic_reset_to_top_level_browsing_context(&state, &session_id);
}
classic_success_into_response(Value::Null)
}
@@ -2521,10 +2685,13 @@ pub(super) async fn webdriver_classic_execute_sync(
Err(error) => return classic_error_into_response(error),
};
apply_classic_script_argument_handles(&mut command, &script_argument_handles);
- let result = binding
- .runtime
- .execute_script(command, binding.timeouts.script.map(Duration::from_millis))
- .await;
+ let result = execute_classic_script_with_argument_page(
+ &binding,
+ command,
+ binding.timeouts.script.map(Duration::from_millis),
+ script_argument_handles.page_residence.clone(),
+ )
+ .await;
release_classic_remote_objects(
&binding,
&context,
@@ -2533,9 +2700,16 @@ pub(super) async fn webdriver_classic_execute_sync(
)
.await;
match result {
- Ok(DevToolsCommandResult::Script(result)) => match *result {
+ Ok((DevToolsCommandResult::Script(result), page_residence)) => match *result {
DevToolsScriptResult::Value(value) => {
- match classic_webdriver_script_result_value(&state, &binding, value.value).await {
+ match classic_webdriver_script_result_value(
+ &state,
+ &binding,
+ &page_residence,
+ value.value,
+ )
+ .await
+ {
Ok(value) => classic_success_into_response(value),
Err(error) => classic_error_into_response(error),
}
@@ -2592,10 +2766,13 @@ pub(super) async fn webdriver_classic_execute_async(
Err(error) => return classic_error_into_response(error),
};
apply_classic_script_argument_handles(&mut command, &script_argument_handles);
- let result = binding
- .runtime
- .execute_script(command, binding.timeouts.script.map(Duration::from_millis))
- .await;
+ let result = execute_classic_script_with_argument_page(
+ &binding,
+ command,
+ binding.timeouts.script.map(Duration::from_millis),
+ script_argument_handles.page_residence.clone(),
+ )
+ .await;
release_classic_remote_objects(
&binding,
&context,
@@ -2604,9 +2781,16 @@ pub(super) async fn webdriver_classic_execute_async(
)
.await;
match result {
- Ok(DevToolsCommandResult::Script(result)) => match *result {
+ Ok((DevToolsCommandResult::Script(result), page_residence)) => match *result {
DevToolsScriptResult::Value(value) => {
- match classic_webdriver_script_result_value(&state, &binding, value.value).await {
+ match classic_webdriver_script_result_value(
+ &state,
+ &binding,
+ &page_residence,
+ value.value,
+ )
+ .await
+ {
Ok(value) => classic_success_into_response(value),
Err(error) => classic_error_into_response(error),
}
@@ -2698,11 +2882,13 @@ pub(super) async fn webdriver_classic_get_element_shadow_root(
return classic_error_into_response(error);
}
+ let page_residence = reference.page_residence.clone();
let result = binding
.runtime
- .execute(describe_node_reference_command(
- &context, reference, 1, true,
- ))
+ .execute_on_page(
+ describe_node_reference_command(&context, reference.reference, 1, true),
+ page_residence.clone(),
+ )
.await;
match result {
Ok(DevToolsCommandResult::DescribeNode(result)) => {
@@ -2716,7 +2902,11 @@ pub(super) async fn webdriver_classic_get_element_shadow_root(
};
classic_success_into_response(
registered_classic_shadow_root_reference_from_dom_reference(
- &state, &binding, node_id, reference,
+ &state,
+ &binding,
+ &page_residence,
+ node_id,
+ reference,
),
)
}
@@ -2751,9 +2941,18 @@ async fn verify_classic_element_attached(
.await?;
let result = binding
.runtime
- .execute(verify_element_attached_command(context, object_id.clone()))
+ .execute_on_page(
+ verify_element_attached_command(context, object_id.object_id.clone()),
+ object_id.page_residence.clone(),
+ )
.await;
- release_classic_remote_object(binding, context, object_id, "get element shadow root").await;
+ release_classic_page_bound_remote_object(
+ binding,
+ context,
+ object_id,
+ "get element shadow root",
+ )
+ .await;
match result {
Ok(DevToolsCommandResult::Script(result)) => match *result {
DevToolsScriptResult::Value(_) => Ok(()),
@@ -2854,12 +3053,20 @@ async fn webdriver_classic_find_shadow_element_with_mode(
{
return classic_error_into_response(error);
}
- let root = Some(shadow_root_reference);
+ let expected_page = shadow_root_reference.page_residence.clone();
+ let root = Some(shadow_root_reference.reference);
let command = match find_element_command_with_root(&context, &params, multiple, root) {
Ok(command) => command,
Err(error) => return classic_error_into_response(error),
};
- match webdriver_classic_execute_find_element_command(&binding, command, multiple).await {
+ match webdriver_classic_execute_find_element_command(
+ &binding,
+ command,
+ multiple,
+ Some(expected_page),
+ )
+ .await
+ {
Ok(result) => {
webdriver_classic_find_element_result_response(
&state,
@@ -2890,22 +3097,25 @@ async fn webdriver_classic_find_element_with_mode_and_root(
Err(error) => return classic_error_into_response(error),
};
let context = classic_browsing_context(&binding);
- let command = if let Some(root_element_id) = root_element_id {
+ let (command, expected_page) = if let Some(root_element_id) = root_element_id {
let root = match resolve_classic_element_dom_reference(&state, &binding, &root_element_id) {
- Ok(reference) => Some(reference),
+ Ok(reference) => reference,
Err(error) => return classic_error_into_response(error),
};
- match find_element_command_with_root(&context, &params, multiple, root) {
- Ok(command) => command,
+ let expected_page = root.page_residence.clone();
+ match find_element_command_with_root(&context, &params, multiple, Some(root.reference)) {
+ Ok(command) => (command, Some(expected_page)),
Err(error) => return classic_error_into_response(error),
}
} else {
match find_element_command(&context, &params, multiple) {
- Ok(command) => command,
+ Ok(command) => (command, None),
Err(error) => return classic_error_into_response(error),
}
};
- match webdriver_classic_execute_find_element_command(&binding, command, multiple).await {
+ match webdriver_classic_execute_find_element_command(&binding, command, multiple, expected_page)
+ .await
+ {
Ok(result) => {
webdriver_classic_find_element_result_response(
&state,
@@ -2923,7 +3133,7 @@ async fn webdriver_classic_find_element_with_mode_and_root(
async fn verify_classic_shadow_root_attached(
binding: &ClassicSessionBinding,
context: &ClassicDevToolsCommandContext,
- shadow_root_reference: DevToolsDomNodeReference,
+ shadow_root_reference: ClassicPageBoundDomReference,
) -> Result<(), ClassicError> {
let object_id = resolve_classic_shadow_root_remote_object_from_reference(
binding,
@@ -2936,21 +3146,33 @@ async fn verify_classic_shadow_root_attached(
.await?;
let result = binding
.runtime
- .execute(shadow_root_attached_command(context, object_id.clone()))
+ .execute_on_page(
+ shadow_root_attached_command(context, object_id.object_id.clone()),
+ object_id.page_residence.clone(),
+ )
.await;
- release_classic_remote_object(binding, context, object_id, "find shadow-root element").await;
+ release_classic_page_bound_remote_object(
+ binding,
+ context,
+ object_id,
+ "find shadow-root element",
+ )
+ .await;
verify_classic_shadow_root_attached_result(result, "find shadow-root element")
}
async fn verify_classic_shadow_root_remote_object_attached(
binding: &ClassicSessionBinding,
context: &ClassicDevToolsCommandContext,
- object_id: &str,
+ remote_object: &ClassicPageBoundRemoteObject,
label: &str,
) -> Result<(), ClassicError> {
let result = binding
.runtime
- .execute(shadow_root_attached_command(context, object_id.to_owned()))
+ .execute_on_page(
+ shadow_root_attached_command(context, remote_object.object_id.clone()),
+ remote_object.page_residence.clone(),
+ )
.await;
verify_classic_shadow_root_attached_result(result, label)
}
@@ -2984,28 +3206,53 @@ async fn webdriver_classic_execute_find_element_command(
binding: &ClassicSessionBinding,
command: DevToolsCommand,
multiple: bool,
-) -> Result<DevToolsCommandResult, DevToolsError> {
+ expected_page: Option<DevToolsPageResidenceIdentity>,
+) -> Result<ClassicFindElementExecution, DevToolsError> {
let implicit_wait = Duration::from_millis(binding.timeouts.implicit.unwrap_or(0));
let started = tokio::time::Instant::now();
loop {
- match binding.runtime.execute(command.clone()).await {
- Ok(DevToolsCommandResult::QuerySelector(result)) => {
+ let execution = match expected_page.as_ref() {
+ Some(expected_page) => binding
+ .runtime
+ .execute_on_page(command.clone(), expected_page.clone())
+ .await
+ .map(|result| (result, expected_page.clone())),
+ None => {
+ binding
+ .runtime
+ .execute_with_page_residence(command.clone())
+ .await
+ }
+ };
+ match execution {
+ Ok((DevToolsCommandResult::QuerySelector(result), page_residence)) => {
if !result.node_ids.is_empty()
|| implicit_wait.is_zero()
|| started.elapsed() >= implicit_wait
{
- return Ok(DevToolsCommandResult::QuerySelector(result));
+ return Ok(ClassicFindElementExecution {
+ result: DevToolsCommandResult::QuerySelector(result),
+ page_residence: Some(page_residence),
+ });
}
}
- Ok(DevToolsCommandResult::LocateNodes(result)) => {
+ Ok((DevToolsCommandResult::LocateNodes(result), page_residence)) => {
if !result.node_ids.is_empty()
|| implicit_wait.is_zero()
|| started.elapsed() >= implicit_wait
{
- return Ok(DevToolsCommandResult::LocateNodes(result));
+ return Ok(ClassicFindElementExecution {
+ result: DevToolsCommandResult::LocateNodes(result),
+ page_residence: Some(page_residence),
+ });
}
}
- Ok(result) => return Ok(result),
+ Ok((result, page_residence)) => {
+ return Ok(ClassicFindElementExecution {
+ result,
+ page_residence: Some(page_residence),
+ });
+ }
Err(error)
if classic_find_element_should_retry_error(&error)
&& !implicit_wait.is_zero()
@@ -3015,23 +3262,42 @@ async fn webdriver_classic_execute_find_element_command(
let remaining = implicit_wait.saturating_sub(started.elapsed());
if remaining.is_zero() {
- return Ok(empty_classic_find_result_for_command(&command, multiple));
+ return Ok(ClassicFindElementExecution {
+ result: empty_classic_find_result_for_command(&command, multiple),
+ page_residence: None,
+ });
}
sleep(remaining.min(CLASSIC_IMPLICIT_WAIT_POLL_INTERVAL)).await;
}
}
+struct ClassicFindElementExecution {
+ result: DevToolsCommandResult,
+ page_residence: Option<DevToolsPageResidenceIdentity>,
+}
+
async fn webdriver_classic_find_element_result_response(
state: &AppState,
binding: &ClassicSessionBinding,
- result: DevToolsCommandResult,
+ execution: ClassicFindElementExecution,
multiple: bool,
label: &str,
) -> Response {
+ let ClassicFindElementExecution {
+ result,
+ page_residence,
+ } = execution;
match result {
DevToolsCommandResult::QuerySelector(result) if multiple => {
+ if result.node_ids.is_empty() {
+ return classic_success_into_response(json!([]));
+ }
+ let page_residence = page_residence
+ .as_ref()
+ .expect("non-empty find result must retain its Page residence");
let references = match classic_find_canonical_dom_references_by_frontend_node_id(
binding,
+ page_residence,
result.node_ids,
label,
)
@@ -3042,13 +3308,23 @@ async fn webdriver_classic_find_element_result_response(
};
classic_success_into_response(json!(
registered_classic_element_references_from_canonical_references(
- state, binding, references
+ state,
+ binding,
+ page_residence,
+ references
)
))
}
DevToolsCommandResult::LocateNodes(result) if multiple => {
+ if result.node_ids.is_empty() {
+ return classic_success_into_response(json!([]));
+ }
+ let page_residence = page_residence
+ .as_ref()
+ .expect("non-empty find result must retain its Page residence");
let references = match classic_find_canonical_dom_references_by_frontend_node_id(
binding,
+ page_residence,
result.node_ids,
label,
)
@@ -3059,7 +3335,10 @@ async fn webdriver_classic_find_element_result_response(
};
classic_success_into_response(json!(
registered_classic_element_references_from_canonical_references(
- state, binding, references
+ state,
+ binding,
+ page_residence,
+ references
)
))
}
@@ -3072,6 +3351,9 @@ async fn webdriver_classic_find_element_result_response(
};
let reference = match classic_find_canonical_dom_reference_for_frontend_node_id(
binding,
+ page_residence
+ .as_ref()
+ .expect("non-empty find result must retain its Page residence"),
frontend_node_id,
label,
)
@@ -3083,6 +3365,9 @@ async fn webdriver_classic_find_element_result_response(
classic_success_into_response(registered_classic_element_reference_from_dom_reference(
state,
binding,
+ page_residence
+ .as_ref()
+ .expect("non-empty find result must retain its Page residence"),
reference.node_id,
reference.reference,
))
@@ -3096,6 +3381,9 @@ async fn webdriver_classic_find_element_result_response(
};
let reference = match classic_find_canonical_dom_reference_for_frontend_node_id(
binding,
+ page_residence
+ .as_ref()
+ .expect("non-empty find result must retain its Page residence"),
frontend_node_id,
label,
)
@@ -3107,6 +3395,9 @@ async fn webdriver_classic_find_element_result_response(
classic_success_into_response(registered_classic_element_reference_from_dom_reference(
state,
binding,
+ page_residence
+ .as_ref()
+ .expect("non-empty find result must retain its Page residence"),
reference.node_id,
reference.reference,
))
@@ -3120,6 +3411,7 @@ async fn webdriver_classic_find_element_result_response(
async fn classic_find_canonical_dom_references_by_frontend_node_id(
binding: &ClassicSessionBinding,
+ page_residence: &DevToolsPageResidenceIdentity,
frontend_node_ids: Vec<u32>,
label: &str,
) -> Result<Vec<ClassicScriptCanonicalNodeReference>, ClassicError> {
@@ -3131,6 +3423,7 @@ async fn classic_find_canonical_dom_references_by_frontend_node_id(
} else {
let reference = classic_find_canonical_dom_reference_for_frontend_node_id(
binding,
+ page_residence,
frontend_node_id,
label,
)
@@ -3145,13 +3438,17 @@ async fn classic_find_canonical_dom_references_by_frontend_node_id(
async fn classic_find_canonical_dom_reference_for_frontend_node_id(
binding: &ClassicSessionBinding,
+ page_residence: &DevToolsPageResidenceIdentity,
frontend_node_id: u32,
label: &str,
) -> Result<ClassicScriptCanonicalNodeReference, ClassicError> {
let context = classic_browsing_context(binding);
match binding
.runtime
- .execute(describe_node_command(&context, frontend_node_id, 0, false))
+ .execute_on_page(
+ describe_node_command(&context, frontend_node_id, 0, false),
+ page_residence.clone(),
+ )
.await
{
Ok(DevToolsCommandResult::DescribeNode(result)) => {
@@ -3203,8 +3500,12 @@ pub(super) async fn webdriver_classic_get_element_attribute(
Ok(reference) => reference,
Err(error) => return classic_error_into_response(error),
};
- let command = get_element_attributes_reference_command(&context, reference);
- match binding.runtime.execute(command).await {
+ let command = get_element_attributes_reference_command(&context, reference.reference);
+ match binding
+ .runtime
+ .execute_on_page(command, reference.page_residence)
+ .await
+ {
Ok(DevToolsCommandResult::GetAttributes(result)) => {
classic_success_into_response(json!(classic_attribute_value(result, &name)))
}
@@ -3249,12 +3550,13 @@ pub(super) async fn webdriver_classic_get_element_text(
};
let result = binding
.runtime
- .execute(get_element_rendered_text_command(
- &context,
- object_id.clone(),
- ))
+ .execute_on_page(
+ get_element_rendered_text_command(&context, object_id.object_id.clone()),
+ object_id.page_residence.clone(),
+ )
+ .await;
+ release_classic_page_bound_remote_object(&binding, &context, object_id, "get element text")
.await;
- release_classic_remote_object(&binding, &context, object_id, "get element text").await;
match result {
Ok(DevToolsCommandResult::Script(result)) => match *result {
DevToolsScriptResult::Value(value) => {
@@ -3282,8 +3584,12 @@ async fn webdriver_classic_get_element_text_from_dom(
Ok(reference) => reference,
Err(error) => return classic_error_into_response(error),
};
- let command = get_element_text_reference_command(context, reference);
- match binding.runtime.execute(command).await {
+ let command = get_element_text_reference_command(context, reference.reference);
+ match binding
+ .runtime
+ .execute_on_page(command, reference.page_residence)
+ .await
+ {
Ok(DevToolsCommandResult::GetText(result)) => {
classic_success_into_response(json!(classic_text_value(result)))
}
@@ -3315,8 +3621,13 @@ pub(super) async fn webdriver_classic_get_element_tag_name(
Ok(reference) => reference,
Err(error) => return classic_error_into_response(error),
};
- let command = get_element_property_reference_command(&context, reference, "localName");
- match binding.runtime.execute(command).await {
+ let command =
+ get_element_property_reference_command(&context, reference.reference, "localName");
+ match binding
+ .runtime
+ .execute_on_page(command, reference.page_residence)
+ .await
+ {
Ok(DevToolsCommandResult::GetProperty(result)) => {
classic_success_into_response(classic_property_value(result))
}
@@ -3339,10 +3650,10 @@ pub(super) async fn webdriver_classic_get_active_element(
let context = classic_browsing_context(&binding);
match binding
.runtime
- .execute(active_element_command(&context))
+ .execute_with_page_residence(active_element_command(&context))
.await
{
- Ok(DevToolsCommandResult::Script(result)) => match *result {
+ Ok((DevToolsCommandResult::Script(result), page_residence)) => match *result {
DevToolsScriptResult::Value(value) => {
let Some(node_id) = value.node_id else {
return classic_error_into_response(ClassicError::new(
@@ -3355,11 +3666,19 @@ pub(super) async fn webdriver_classic_get_active_element(
.map(DevToolsDomNodeReference::BackendNodeId)
.unwrap_or(DevToolsDomNodeReference::FrontendNodeId(node_id));
let owner_node_id = value.backend_node_id.unwrap_or(node_id);
- release_classic_remote_handle(&binding, &context, &value, "active element").await;
+ release_classic_remote_handle(
+ &binding,
+ &context,
+ &value,
+ &page_residence,
+ "active element",
+ )
+ .await;
classic_success_into_response(
registered_classic_element_reference_from_dom_reference(
&state,
&binding,
+ &page_residence,
owner_node_id,
reference,
),
@@ -3406,8 +3725,12 @@ async fn classic_element_live_identity(
element_id: &str,
) -> Result<ClassicElementLiveIdentity, ClassicError> {
let reference = resolve_classic_element_dom_reference(state, binding, element_id)?;
- let command = describe_node_reference_command(context, reference, 0, false);
- match binding.runtime.execute(command).await {
+ let command = describe_node_reference_command(context, reference.reference, 0, false);
+ match binding
+ .runtime
+ .execute_on_page(command, reference.page_residence)
+ .await
+ {
Ok(DevToolsCommandResult::DescribeNode(result)) => {
classic_element_live_identity_from_described_node(&result.node).ok_or_else(|| {
ClassicError::new(
@@ -3465,9 +3788,13 @@ pub(super) async fn webdriver_classic_is_element_enabled(
};
let result = binding
.runtime
- .execute(get_element_enabled_command(&context, object_id.clone()))
+ .execute_on_page(
+ get_element_enabled_command(&context, object_id.object_id.clone()),
+ object_id.page_residence.clone(),
+ )
+ .await;
+ release_classic_page_bound_remote_object(&binding, &context, object_id, "is element enabled")
.await;
- release_classic_remote_object(&binding, &context, object_id, "is element enabled").await;
match result {
Ok(DevToolsCommandResult::Script(result)) => match *result {
DevToolsScriptResult::Value(value) => {
@@ -3571,8 +3898,12 @@ pub(super) async fn webdriver_classic_get_element_rect(
Ok(reference) => reference,
Err(error) => return classic_error_into_response(error),
};
- let command = get_element_rect_reference_command(&context, reference);
- match binding.runtime.execute(command).await {
+ let command = get_element_rect_reference_command(&context, reference.reference);
+ match binding
+ .runtime
+ .execute_on_page(command, reference.page_residence)
+ .await
+ {
Ok(DevToolsCommandResult::DomGeometry(result)) => match classic_rect_from_geometry(&result)
{
Ok(rect) => classic_success_into_response(rect),
@@ -3610,9 +3941,13 @@ pub(super) async fn webdriver_classic_take_element_screenshot(
};
let result = binding
.runtime
- .execute(element_screenshot_command(&context, object_id.clone()))
+ .execute_on_page(
+ element_screenshot_command(&context, object_id.object_id.clone()),
+ object_id.page_residence.clone(),
+ )
+ .await;
+ release_classic_page_bound_remote_object(&binding, &context, object_id, "element screenshot")
.await;
- release_classic_remote_object(&binding, &context, object_id, "element screenshot").await;
match result {
Ok(_) => classic_error_into_response(ClassicError::new(
ClassicErrorCode::UnknownError,
@@ -3644,9 +3979,19 @@ pub(super) async fn webdriver_classic_get_element_css_value(
Ok(object_id) => object_id,
Err(error) => return classic_error_into_response(error),
};
- let command = get_element_css_value_command(&context, object_id.clone(), property_name);
- let result = binding.runtime.execute(command).await;
- release_classic_remote_object(&binding, &context, object_id, "get element CSS value").await;
+ let command =
+ get_element_css_value_command(&context, object_id.object_id.clone(), property_name);
+ let result = binding
+ .runtime
+ .execute_on_page(command, object_id.page_residence.clone())
+ .await;
+ release_classic_page_bound_remote_object(
+ &binding,
+ &context,
+ object_id,
+ "get element CSS value",
+ )
+ .await;
match result {
Ok(DevToolsCommandResult::Script(result)) => match *result {
DevToolsScriptResult::Value(value) => {
@@ -3749,9 +4094,12 @@ async fn webdriver_classic_get_element_computed_value(
};
let result = binding
.runtime
- .execute(kind.command(&context, object_id.clone()))
+ .execute_on_page(
+ kind.command(&context, object_id.object_id.clone()),
+ object_id.page_residence.clone(),
+ )
.await;
- release_classic_remote_object(&binding, &context, object_id, kind.label()).await;
+ release_classic_page_bound_remote_object(&binding, &context, object_id, kind.label()).await;
match result {
Ok(DevToolsCommandResult::Script(result)) => match *result {
DevToolsScriptResult::Value(value) => {
@@ -3791,9 +4139,13 @@ pub(super) async fn webdriver_classic_is_element_displayed(
Ok(object_id) => object_id,
Err(error) => return classic_error_into_response(error),
};
- let command = get_element_displayed_command(&context, object_id.clone());
- let result = binding.runtime.execute(command).await;
- release_classic_remote_object(&binding, &context, object_id, "is element displayed").await;
+ let command = get_element_displayed_command(&context, object_id.object_id.clone());
+ let result = binding
+ .runtime
+ .execute_on_page(command, object_id.page_residence.clone())
+ .await;
+ release_classic_page_bound_remote_object(&binding, &context, object_id, "is element displayed")
+ .await;
match result {
Ok(DevToolsCommandResult::Script(result)) => match *result {
DevToolsScriptResult::Value(value) => {
@@ -3820,8 +4172,12 @@ async fn webdriver_classic_element_property_value(
label: &'static str,
) -> Result<Value, ClassicError> {
let reference = resolve_classic_element_dom_reference(state, binding, element_id)?;
- let command = get_element_property_reference_command(context, reference, name);
- match binding.runtime.execute(command).await {
+ let command = get_element_property_reference_command(context, reference.reference, name);
+ match binding
+ .runtime
+ .execute_on_page(command, reference.page_residence)
+ .await
+ {
Ok(DevToolsCommandResult::GetProperty(result)) => Ok(classic_property_value(result)),
Ok(_) => Err(ClassicError::new(
ClassicErrorCode::UnknownError,
@@ -3864,10 +4220,13 @@ pub(super) async fn webdriver_classic_get_element_property(
Err(error) => return classic_error_into_response(error),
};
apply_classic_script_argument_handles(&mut command, &script_argument_handles);
- let result = binding
- .runtime
- .execute_script(command, binding.timeouts.script.map(Duration::from_millis))
- .await;
+ let result = execute_classic_script_with_argument_page(
+ &binding,
+ command,
+ binding.timeouts.script.map(Duration::from_millis),
+ script_argument_handles.page_residence.clone(),
+ )
+ .await;
release_classic_remote_objects(
&binding,
&context,
@@ -3876,9 +4235,16 @@ pub(super) async fn webdriver_classic_get_element_property(
)
.await;
match result {
- Ok(DevToolsCommandResult::Script(result)) => match *result {
+ Ok((DevToolsCommandResult::Script(result), page_residence)) => match *result {
DevToolsScriptResult::Value(value) => {
- match classic_webdriver_script_result_value(&state, &binding, value.value).await {
+ match classic_webdriver_script_result_value(
+ &state,
+ &binding,
+ &page_residence,
+ value.value,
+ )
+ .await
+ {
Ok(value) => classic_success_into_response(value),
Err(error) => classic_error_into_response(error),
}
@@ -3929,9 +4295,12 @@ pub(super) async fn webdriver_classic_clear_element(
let result = binding
.runtime
- .execute(clear_element_command(&context, object_id.clone()))
+ .execute_on_page(
+ clear_element_command(&context, object_id.object_id.clone()),
+ object_id.page_residence.clone(),
+ )
.await;
- release_classic_remote_object(&binding, &context, object_id, "clear element").await;
+ release_classic_page_bound_remote_object(&binding, &context, object_id, "clear element").await;
match result {
Ok(DevToolsCommandResult::Script(result)) => match *result {
DevToolsScriptResult::Value(value) => match classic_clear_element_result(value.value) {
@@ -4109,9 +4478,19 @@ async fn webdriver_classic_prepare_text_control_for_send_keys(
"element send keys preflight",
)
.await?;
- let command = element_send_keys_prepare_text_control_command(context, object_id.clone(), text);
- let result = binding.runtime.execute(command).await;
- release_classic_remote_object(binding, context, object_id, "element send keys preflight").await;
+ let command =
+ element_send_keys_prepare_text_control_command(context, object_id.object_id.clone(), text);
+ let result = binding
+ .runtime
+ .execute_on_page(command, object_id.page_residence.clone())
+ .await;
+ release_classic_page_bound_remote_object(
+ binding,
+ context,
+ object_id,
+ "element send keys preflight",
+ )
+ .await;
match result {
Ok(DevToolsCommandResult::Script(result)) => match *result {
DevToolsScriptResult::Value(value) => match value.value.as_str() {
@@ -4154,13 +4533,14 @@ async fn webdriver_classic_activate_element_by_handle(
.await?;
let result = binding
.runtime
- .execute_with_pending_navigation_wait(
- element_click_command(context, object_id.clone()),
+ .execute_with_pending_navigation_wait_on_page(
+ element_click_command(context, object_id.object_id.clone()),
None,
binding.timeouts.page_load.map(Duration::from_millis),
+ object_id.page_residence.clone(),
)
.await;
- release_classic_remote_object(binding, context, object_id, object_group).await;
+ release_classic_page_bound_remote_object(binding, context, object_id, object_group).await;
let post_click_navigation = classic_wait_for_current_document(binding).await;
match result {
Ok(DevToolsCommandResult::Script(result)) => {
@@ -4282,21 +4662,23 @@ async fn webdriver_classic_send_file_input_keys(
.await?;
let result = binding
.runtime
- .execute(DevToolsCommand::SetFileInputFiles(
- DevToolsSetFileInputFilesCommand {
+ .execute_on_page(
+ DevToolsCommand::SetFileInputFiles(DevToolsSetFileInputFilesCommand {
context: DevToolsCommandContext {
protocol: DevToolsProtocol::WebDriverClassic,
session_id: Some(DevToolsSessionId::from(context.session_id.as_str())),
target_id: context.target_id.as_deref().map(DevToolsTargetId::from),
browser_context_id: None,
},
- object_id: DevToolsRemoteHandleId::from(object_id.as_str()),
+ object_id: DevToolsRemoteHandleId::from(object_id.object_id.as_str()),
files,
append: multiple,
- },
- ))
+ }),
+ object_id.page_residence.clone(),
+ )
+ .await;
+ release_classic_page_bound_remote_object(binding, context, object_id, "element file upload")
.await;
- release_classic_remote_object(binding, context, object_id, "element file upload").await;
match result {
Ok(DevToolsCommandResult::Empty) => Ok(()),
Ok(_) => Err(ClassicError::new(
@@ -4335,10 +4717,15 @@ async fn webdriver_classic_element_geometry(
element_id: &str,
) -> Result<DevToolsDomGeometryResult, ClassicError> {
let reference = resolve_classic_element_dom_reference(state, binding, element_id)?;
- let commands = element_click_prepare_reference_commands(context, reference);
+ let page_residence = reference.page_residence;
+ let commands = element_click_prepare_reference_commands(context, reference.reference);
let mut geometry = None;
for command in commands {
- match binding.runtime.execute(command).await {
+ match binding
+ .runtime
+ .execute_on_page(command, page_residence.clone())
+ .await
+ {
Ok(DevToolsCommandResult::Empty) => {}
Ok(DevToolsCommandResult::DomGeometry(result)) => geometry = Some(result),
Ok(_) => {
diff --git a/moli-protocol-server/src/protocol_server/webdriver_classic/dom_refs.rs b/moli-protocol-server/src/protocol_server/webdriver_classic/dom_refs.rs
index ef739cbb5..d26317261 100644
--- a/moli-protocol-server/src/protocol_server/webdriver_classic/dom_refs.rs
+++ b/moli-protocol-server/src/protocol_server/webdriver_classic/dom_refs.rs
@@ -1,14 +1,13 @@
-use moli_protocol::devtools_runtime::DevToolsDomNodeReference;
use moli_protocol_webdriver_classic::ClassicError;
use super::super::AppState;
-use super::state::ClassicSessionBinding;
+use super::state::{ClassicPageBoundDomReference, ClassicSessionBinding};
pub(super) fn resolve_classic_element_dom_reference(
state: &AppState,
binding: &ClassicSessionBinding,
element_id: &str,
-) -> Result<DevToolsDomNodeReference, ClassicError> {
+) -> Result<ClassicPageBoundDomReference, ClassicError> {
state
.classic_session_registry
.lock()
@@ -19,7 +18,7 @@ pub(super) fn resolve_classic_shadow_root_dom_reference(
state: &AppState,
binding: &ClassicSessionBinding,
shadow_root_id: &str,
-) -> Result<DevToolsDomNodeReference, ClassicError> {
+) -> Result<ClassicPageBoundDomReference, ClassicError> {
state
.classic_session_registry
.lock()
diff --git a/moli-protocol-server/src/protocol_server/webdriver_classic/state.rs b/moli-protocol-server/src/protocol_server/webdriver_classic/state.rs
index d98410aeb..274c22718 100644
--- a/moli-protocol-server/src/protocol_server/webdriver_classic/state.rs
+++ b/moli-protocol-server/src/protocol_server/webdriver_classic/state.rs
@@ -10,7 +10,7 @@ use axum::extract::ws::WebSocket;
use moli_cookie_jar::StoredCookie;
use moli_core::{page::RendererDocumentLifecycleMilestone, runtime::NavigationRuntimeConfig};
use moli_protocol::{
- CdpInitialStoragePartition,
+ CdpInitialStoragePartition, DevToolsPageResidenceIdentity,
devtools_runtime::{
DevToolsCommand, DevToolsCommandContext, DevToolsCommandResult, DevToolsDomNodeReference,
DevToolsError, DevToolsErrorKind, DevToolsFrameId, DevToolsGetFrameOwnerCommand,
@@ -30,7 +30,8 @@ use parking_lot::Mutex;
use tokio::sync::{mpsc, oneshot};
use crate::cdp_scheduler::{
- CdpScheduler, CdpSchedulerEventReceivers, DevToolsCommandExecution, ProtocolAdapterScheduler,
+ CdpScheduler, CdpSchedulerEventReceivers, DevToolsCommandExecution,
+ DevToolsPageCommandExecution, ProtocolAdapterScheduler,
};
use super::super::webdriver_bidi::{
@@ -80,7 +81,6 @@ pub(super) struct ClassicSessionManager {
element_owners: BTreeMap<(String, String), ClassicElementOwner>,
element_ids_by_owner: BTreeMap<(String, ClassicElementOwner), String>,
shadow_root_owners: BTreeMap<(String, String), ClassicShadowRootOwner>,
- document_generations: BTreeMap<(String, String), u64>,
window_positions: BTreeMap<(String, String), ClassicWindowPosition>,
uploaded_files: BTreeMap<String, Vec<PathBuf>>,
download_directories: BTreeMap<String, PathBuf>,
@@ -89,19 +89,23 @@ pub(super) struct ClassicSessionManager {
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
struct ClassicElementOwner {
node_id: u32,
- reference: DevToolsDomNodeReference,
+ reference: ClassicPageBoundDomReference,
target_id: String,
browsing_context_target_id: String,
- document_generation: u64,
}
#[derive(Debug, Clone)]
struct ClassicShadowRootOwner {
node_id: u32,
- reference: DevToolsDomNodeReference,
+ reference: ClassicPageBoundDomReference,
target_id: String,
browsing_context_target_id: String,
- document_generation: u64,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub(super) struct ClassicPageBoundDomReference {
+ pub(super) page_residence: DevToolsPageResidenceIdentity,
+ pub(super) reference: DevToolsDomNodeReference,
}
impl ClassicSessionManager {
@@ -223,15 +227,13 @@ impl ClassicSessionManager {
&mut self,
binding: &ClassicSessionBinding,
node_id: u32,
- reference: DevToolsDomNodeReference,
+ reference: ClassicPageBoundDomReference,
) -> String {
- let document_generation = self.document_generation(&binding.session_id, &binding.target_id);
let owner = ClassicElementOwner {
node_id,
reference,
target_id: binding.target_id.clone(),
browsing_context_target_id: binding.browsing_context_target_id().to_owned(),
- document_generation,
};
let owner_key = (binding.session_id.clone(), owner.clone());
if let Some(element_id) = self.element_ids_by_owner.get(&owner_key) {
@@ -251,9 +253,8 @@ impl ClassicSessionManager {
&mut self,
binding: &ClassicSessionBinding,
node_id: u32,
- reference: DevToolsDomNodeReference,
+ reference: ClassicPageBoundDomReference,
) -> String {
- let document_generation = self.document_generation(&binding.session_id, &binding.target_id);
if let Some(((_, shadow_root_id), _)) =
self.shadow_root_owners
.iter()
@@ -263,7 +264,6 @@ impl ClassicSessionManager {
&& owner.reference == reference
&& owner.target_id == binding.target_id
&& owner.browsing_context_target_id == binding.browsing_context_target_id()
- && owner.document_generation == document_generation
})
{
return shadow_root_id.clone();
@@ -278,7 +278,6 @@ impl ClassicSessionManager {
reference,
target_id: binding.target_id.clone(),
browsing_context_target_id: binding.browsing_context_target_id().to_owned(),
- document_generation,
},
);
shadow_root_id
@@ -288,7 +287,7 @@ impl ClassicSessionManager {
&self,
binding: &ClassicSessionBinding,
element_id: &str,
- ) -> Result<DevToolsDomNodeReference, ClassicError> {
+ ) -> Result<ClassicPageBoundDomReference, ClassicError> {
Ok(self
.resolve_element_owner(binding, element_id)?
.reference
@@ -318,14 +317,6 @@ impl ClassicSessionManager {
"element not found in the current browsing context",
));
}
- if owner.document_generation
- != self.document_generation(&binding.session_id, &owner.target_id)
- {
- return Err(ClassicError::new(
- ClassicErrorCode::StaleElementReference,
- "element is no longer attached to the DOM",
- ));
- }
Ok(owner)
}
@@ -333,7 +324,7 @@ impl ClassicSessionManager {
&self,
binding: &ClassicSessionBinding,
shadow_root_id: &str,
- ) -> Result<DevToolsDomNodeReference, ClassicError> {
+ ) -> Result<ClassicPageBoundDomReference, ClassicError> {
Ok(self
.resolve_shadow_root_owner(binding, shadow_root_id)?
.reference
@@ -363,31 +354,9 @@ impl ClassicSessionManager {
"shadow root not found",
));
}
- if owner.document_generation
- != self.document_generation(&binding.session_id, &owner.target_id)
- {
- return Err(ClassicError::new(
- ClassicErrorCode::DetachedShadowRoot,
- "shadow root is detached",
- ));
- }
Ok(owner)
}
- pub(super) fn bump_document_generation(&mut self, session_id: &str, target_id: &str) {
- *self
- .document_generations
- .entry((session_id.to_owned(), target_id.to_owned()))
- .or_default() += 1;
- }
-
- fn document_generation(&self, session_id: &str, target_id: &str) -> u64 {
- self.document_generations
- .get(&(session_id.to_owned(), target_id.to_owned()))
- .copied()
- .unwrap_or_default()
- }
-
pub(super) fn timeouts(&self, session_id: &str) -> Option<ClassicTimeouts> {
self.registry.timeouts(session_id)
}
@@ -467,8 +436,6 @@ impl ClassicSessionManager {
.retain(|(owner_session_id, _), _| owner_session_id != session_id);
self.shadow_root_owners
.retain(|(owner_session_id, _), _| owner_session_id != session_id);
- self.document_generations
- .retain(|(owner_session_id, _), _| owner_session_id != session_id);
self.window_positions
.retain(|(owner_session_id, _), _| owner_session_id != session_id);
if let Some(paths) = self.uploaded_files.remove(session_id) {
@@ -542,23 +509,32 @@ impl ClassicSessionRuntimeHandle {
.await
}
- pub(super) async fn execute_script(
+ pub(super) async fn execute_with_pending_navigation_wait(
&self,
command: DevToolsCommand,
timeout: Option<Duration>,
+ pending_navigation_timeout: Option<Duration>,
) -> Result<DevToolsCommandResult, DevToolsError> {
- self.execute_with_options(command, timeout, None, true)
+ self.execute_with_options(command, timeout, pending_navigation_timeout, false)
.await
}
- pub(super) async fn execute_with_pending_navigation_wait(
+ pub(super) async fn execute_with_pending_navigation_wait_on_page(
&self,
command: DevToolsCommand,
timeout: Option<Duration>,
pending_navigation_timeout: Option<Duration>,
+ expected_page: DevToolsPageResidenceIdentity,
) -> Result<DevToolsCommandResult, DevToolsError> {
- self.execute_with_options(command, timeout, pending_navigation_timeout, false)
- .await
+ self.execute_request(
+ command,
+ timeout,
+ pending_navigation_timeout,
+ false,
+ Some(expected_page),
+ )
+ .await
+ .result
}
pub(super) async fn wait_for_document_lifecycle(
@@ -596,6 +572,79 @@ impl ClassicSessionRuntimeHandle {
pending_navigation_timeout: Option<Duration>,
terminate_execution_on_timeout: bool,
) -> Result<DevToolsCommandResult, DevToolsError> {
+ self.execute_request(
+ command,
+ timeout,
+ pending_navigation_timeout,
+ terminate_execution_on_timeout,
+ None,
+ )
+ .await
+ .result
+ }
+
+ pub(super) async fn execute_with_page_residence(
+ &self,
+ command: DevToolsCommand,
+ ) -> Result<(DevToolsCommandResult, DevToolsPageResidenceIdentity), DevToolsError> {
+ let execution = self.execute_request(command, None, None, false, None).await;
+ let result = execution.result?;
+ let page_residence = execution.page_residence.ok_or_else(|| {
+ DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "Classic command did not address a live Page",
+ )
+ })?;
+ Ok((result, page_residence))
+ }
+
+ pub(super) async fn execute_script_with_page_residence(
+ &self,
+ command: DevToolsCommand,
+ timeout: Option<Duration>,
+ ) -> Result<(DevToolsCommandResult, DevToolsPageResidenceIdentity), DevToolsError> {
+ let execution = self
+ .execute_request(command, timeout, None, true, None)
+ .await;
+ let result = execution.result?;
+ let page_residence = execution.page_residence.ok_or_else(|| {
+ DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "Classic script did not address a live Page",
+ )
+ })?;
+ Ok((result, page_residence))
+ }
+
+ pub(super) async fn execute_on_page(
+ &self,
+ command: DevToolsCommand,
+ expected_page: DevToolsPageResidenceIdentity,
+ ) -> Result<DevToolsCommandResult, DevToolsError> {
+ self.execute_request(command, None, None, false, Some(expected_page))
+ .await
+ .result
+ }
+
+ pub(super) async fn execute_script_on_page(
+ &self,
+ command: DevToolsCommand,
+ timeout: Option<Duration>,
+ expected_page: DevToolsPageResidenceIdentity,
+ ) -> Result<DevToolsCommandResult, DevToolsError> {
+ self.execute_request(command, timeout, None, true, Some(expected_page))
+ .await
+ .result
+ }
+
+ async fn execute_request(
+ &self,
+ command: DevToolsCommand,
+ timeout: Option<Duration>,
+ pending_navigation_timeout: Option<Duration>,
+ terminate_execution_on_timeout: bool,
+ expected_page: Option<DevToolsPageResidenceIdentity>,
+ ) -> ClassicSessionRuntimeCommandExecution {
let (response_tx, response_rx) = oneshot::channel();
self.tx
.send(ClassicSessionRuntimeRequest::Execute {
@@ -603,20 +652,16 @@ impl ClassicSessionRuntimeHandle {
timeout,
pending_navigation_timeout,
terminate_execution_on_timeout,
+ expected_page,
response_tx,
})
- .map_err(|_| {
- DevToolsError::new(
- DevToolsErrorKind::NoSuchSession,
- "Classic session runtime is closed",
- )
- })?;
- response_rx.await.map_err(|_| {
- DevToolsError::new(
+ .ok();
+ response_rx.await.unwrap_or_else(|_| {
+ ClassicSessionRuntimeCommandExecution::error(DevToolsError::new(
DevToolsErrorKind::NoSuchSession,
"Classic session runtime stopped before command completion",
- )
- })?
+ ))
+ })
}
pub(super) async fn frame_id_for_index(
@@ -654,7 +699,7 @@ impl ClassicSessionRuntimeHandle {
session_id: String,
target_id: String,
current_frame_id: Option<String>,
- element_reference: DevToolsDomNodeReference,
+ element_reference: ClassicPageBoundDomReference,
) -> Result<String, DevToolsError> {
let (response_tx, response_rx) = oneshot::channel();
self.tx
@@ -662,7 +707,8 @@ impl ClassicSessionRuntimeHandle {
session_id,
target_id,
current_frame_id,
- element_reference,
+ expected_page: element_reference.page_residence,
+ element_reference: element_reference.reference,
response_tx,
})
.map_err(|_| {
@@ -802,13 +848,28 @@ impl ClassicSessionRuntimeHandle {
}
}
+struct ClassicSessionRuntimeCommandExecution {
+ result: Result<DevToolsCommandResult, DevToolsError>,
+ page_residence: Option<DevToolsPageResidenceIdentity>,
+}
+
+impl ClassicSessionRuntimeCommandExecution {
+ fn error(error: DevToolsError) -> Self {
+ Self {
+ result: Err(error),
+ page_residence: None,
+ }
+ }
+}
+
enum ClassicSessionRuntimeRequest {
Execute {
command: Box<DevToolsCommand>,
timeout: Option<Duration>,
pending_navigation_timeout: Option<Duration>,
terminate_execution_on_timeout: bool,
- response_tx: oneshot::Sender<Result<DevToolsCommandResult, DevToolsError>>,
+ expected_page: Option<DevToolsPageResidenceIdentity>,
+ response_tx: oneshot::Sender<ClassicSessionRuntimeCommandExecution>,
},
WaitForDocumentLifecycle {
context: DevToolsCommandContext,
@@ -835,6 +896,7 @@ enum ClassicSessionRuntimeRequest {
session_id: String,
target_id: String,
current_frame_id: Option<String>,
+ expected_page: DevToolsPageResidenceIdentity,
element_reference: DevToolsDomNodeReference,
response_tx: oneshot::Sender<Result<String, DevToolsError>>,
},
@@ -896,8 +958,21 @@ async fn handle_classic_session_runtime_request(
timeout,
pending_navigation_timeout,
terminate_execution_on_timeout,
+ expected_page,
response_tx,
} => {
+ if expected_page.as_ref().is_some_and(|expected| {
+ scheduler.page_residence_identity_for_devtools_context(command.context())
+ != Some(expected.clone())
+ }) {
+ let _ = response_tx.send(ClassicSessionRuntimeCommandExecution::error(
+ DevToolsError::new(
+ DevToolsErrorKind::NoSuchNode,
+ "DOM reference belongs to a replaced Page",
+ ),
+ ));
+ return ClassicSessionRuntimeRequestOutcome::Continue;
+ }
let termination_context = command.context().clone();
let mut execution = execute_classic_devtools_command_with_pending_navigation_retry(
scheduler,
@@ -905,11 +980,12 @@ async fn handle_classic_session_runtime_request(
*command,
timeout,
pending_navigation_timeout,
+ expected_page.as_ref(),
)
.await;
if terminate_execution_on_timeout
&& matches!(
- execution.result,
+ execution.execution.result,
Err(ref error) if error.kind == DevToolsErrorKind::Timeout
)
{
@@ -923,33 +999,38 @@ async fn handle_classic_session_runtime_request(
context: termination_context,
}),
Some(CLASSIC_SCRIPT_TERMINATION_TIMEOUT),
+ execution.page_residence.as_ref(),
)
.await;
- if let Err(error) = &termination.result {
+ if let Err(error) = &termination.execution.result {
tracing::warn!(
?error,
"failed to terminate timed-out WebDriver Classic script execution"
);
}
execution
+ .execution
.protocol_output
- .append(termination.protocol_output);
+ .append(termination.execution.protocol_output);
}
- let result = execution.result;
+ let result = execution.execution.result;
let keep_attached = if let Some(attached) = attached_bidi.as_mut() {
attached
.actor
.send_or_route_protocol_output(
scheduler,
receivers,
- execution.protocol_output,
+ execution.execution.protocol_output,
None,
)
.await
} else {
true
};
- let _ = response_tx.send(result);
+ let _ = response_tx.send(ClassicSessionRuntimeCommandExecution {
+ result,
+ page_residence: execution.page_residence,
+ });
if keep_attached {
ClassicSessionRuntimeRequestOutcome::Continue
} else {
@@ -1040,6 +1121,7 @@ async fn handle_classic_session_runtime_request(
session_id,
target_id,
current_frame_id,
+ expected_page,
element_reference,
response_tx,
} => {
@@ -1049,6 +1131,7 @@ async fn handle_classic_session_runtime_request(
&session_id,
&target_id,
current_frame_id.as_deref(),
+ &expected_page,
element_reference,
)
.await;
@@ -1122,41 +1205,49 @@ async fn execute_classic_devtools_command_with_pending_navigation_retry(
command: DevToolsCommand,
timeout: Option<Duration>,
pending_navigation_timeout: Option<Duration>,
-) -> DevToolsCommandExecution {
- let mut execution =
- execute_classic_devtools_command_once(scheduler, receivers, command.clone(), timeout).await;
+ expected_page: Option<&DevToolsPageResidenceIdentity>,
+) -> ClassicDevToolsCommandExecution {
+ let mut execution = execute_classic_devtools_command_once(
+ scheduler,
+ receivers,
+ command.clone(),
+ timeout,
+ expected_page,
+ )
+ .await;
let Some(pending_navigation_timeout) = pending_navigation_timeout else {
return execution;
};
let started = Instant::now();
loop {
- if !classic_runtime_result_is_navigation_changing_document(&execution.result) {
+ if !classic_runtime_result_is_navigation_changing_document(&execution.execution.result) {
return execution;
}
let Some(remaining) = pending_navigation_timeout.checked_sub(started.elapsed()) else {
- execution.result = Err(classic_pending_navigation_timeout_error());
+ execution.execution.result = Err(classic_pending_navigation_timeout_error());
return execution;
};
let mut progress = scheduler
.complete_ready_protocol_residences_for_external_load_wait()
.await;
if progress.is_empty() {
- let input =
- match tokio::time::timeout(remaining, receivers.recv_interleaved_input()).await {
- Ok(Some(input)) => input,
- Ok(None) => {
- execution.result = Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchSession,
- "Classic session runtime stopped while waiting for navigation",
- ));
- return execution;
- }
- Err(_) => {
- execution.result = Err(classic_pending_navigation_timeout_error());
- return execution;
- }
- };
+ let input = match tokio::time::timeout(remaining, receivers.recv_interleaved_input())
+ .await
+ {
+ Ok(Some(input)) => input,
+ Ok(None) => {
+ execution.execution.result = Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchSession,
+ "Classic session runtime stopped while waiting for navigation",
+ ));
+ return execution;
+ }
+ Err(_) => {
+ execution.execution.result = Err(classic_pending_navigation_timeout_error());
+ return execution;
+ }
+ };
// Once selected, finish the move-owned input outside the timeout
// race. In particular, an admitted renderer publication must not
// disappear merely because the navigation deadline expires while
@@ -1168,19 +1259,19 @@ async fn execute_classic_devtools_command_with_pending_navigation_retry(
Ok(progress) => progress,
Err(failure) => {
let (progress, error) = failure.into_parts();
- execution.protocol_output.append(progress);
- execution.result = Err(error);
+ execution.execution.protocol_output.append(progress);
+ execution.execution.result = Err(error);
return execution;
}
};
}
- execution.protocol_output.append(progress);
+ execution.execution.protocol_output.append(progress);
let retry_timeout = match timeout {
Some(timeout) => {
let Some(remaining) = pending_navigation_timeout.checked_sub(started.elapsed())
else {
- execution.result = Err(classic_pending_navigation_timeout_error());
+ execution.execution.result = Err(classic_pending_navigation_timeout_error());
return execution;
};
Some(timeout.min(remaining))
@@ -1192,10 +1283,15 @@ async fn execute_classic_devtools_command_with_pending_navigation_retry(
receivers,
command.clone(),
retry_timeout,
+ expected_page,
)
.await;
- execution.protocol_output.append(retry.protocol_output);
- execution.result = retry.result;
+ execution
+ .execution
+ .protocol_output
+ .append(retry.execution.protocol_output);
+ execution.execution.result = retry.execution.result;
+ execution.page_residence = retry.page_residence;
}
}
@@ -1204,25 +1300,30 @@ async fn execute_classic_devtools_command_once(
receivers: &mut CdpSchedulerEventReceivers,
command: DevToolsCommand,
timeout: Option<Duration>,
-) -> DevToolsCommandExecution {
- match timeout {
- Some(timeout) => {
- scheduler
- .execute_devtools_command_with_external_load_wait_and_protocol_messages_timeout(
- receivers, command, timeout,
- )
- .await
- }
- None => {
- scheduler
- .execute_devtools_command_with_external_load_wait_and_protocol_messages(
- receivers, command,
- )
- .await
- }
+ expected_page: Option<&DevToolsPageResidenceIdentity>,
+) -> ClassicDevToolsCommandExecution {
+ let DevToolsPageCommandExecution {
+ execution,
+ page_residence,
+ } = scheduler
+ .execute_devtools_command_with_external_load_wait_and_page_residence(
+ receivers,
+ command,
+ timeout,
+ expected_page,
+ )
+ .await;
+ ClassicDevToolsCommandExecution {
+ execution,
+ page_residence,
}
}
+struct ClassicDevToolsCommandExecution {
+ execution: DevToolsCommandExecution,
+ page_residence: Option<DevToolsPageResidenceIdentity>,
+}
+
fn classic_runtime_result_is_navigation_changing_document(
result: &Result<DevToolsCommandResult, DevToolsError>,
) -> bool {
@@ -1505,9 +1606,12 @@ async fn resolve_classic_frame_id_for_element(
session_id: &str,
target_id: &str,
current_frame_id: Option<&str>,
+ expected_page: &DevToolsPageResidenceIdentity,
element_reference: DevToolsDomNodeReference,
) -> Result<String, DevToolsError> {
- let frame_tree = classic_frame_tree(scheduler, receivers, session_id, target_id).await?;
+ let frame_tree =
+ classic_frame_tree_on_page(scheduler, receivers, session_id, target_id, expected_page)
+ .await?;
let candidate_frames = match current_frame_id {
Some(frame_id) => {
classic_child_frames_for_frame_id(&frame_tree, frame_id).ok_or_else(|| {
@@ -1523,9 +1627,15 @@ async fn resolve_classic_frame_id_for_element(
let Some(frame_id) = classic_frame_tree_item_frame_id(candidate) else {
continue;
};
- let owner =
- classic_frame_owner_reference(scheduler, receivers, session_id, target_id, frame_id)
- .await?;
+ let owner = classic_frame_owner_reference_on_page(
+ scheduler,
+ receivers,
+ session_id,
+ target_id,
+ frame_id,
+ expected_page,
+ )
+ .await?;
if classic_frame_owner_matches_reference(&owner, &element_reference) {
return Ok(frame_id.to_owned());
}
@@ -1536,12 +1646,13 @@ async fn resolve_classic_frame_id_for_element(
))
}
-async fn classic_frame_owner_reference(
+async fn classic_frame_owner_reference_on_page(
scheduler: &mut CdpScheduler,
receivers: &mut CdpSchedulerEventReceivers,
session_id: &str,
target_id: &str,
frame_id: &str,
+ expected_page: &DevToolsPageResidenceIdentity,
) -> Result<DevToolsGetFrameOwnerResult, DevToolsError> {
let context = DevToolsCommandContext {
protocol: DevToolsProtocol::WebDriverClassic,
@@ -1549,6 +1660,7 @@ async fn classic_frame_owner_reference(
target_id: Some(DevToolsTargetId::from(target_id)),
browser_context_id: None,
};
+ ensure_classic_command_page_is_current(scheduler, &context, expected_page)?;
match scheduler
.execute_devtools_command_with_external_load_wait(
receivers,
@@ -1641,6 +1753,56 @@ async fn classic_frame_tree(
}
}
+async fn classic_frame_tree_on_page(
+ scheduler: &mut CdpScheduler,
+ receivers: &mut CdpSchedulerEventReceivers,
+ session_id: &str,
+ target_id: &str,
+ expected_page: &DevToolsPageResidenceIdentity,
+) -> Result<serde_json::Value, DevToolsError> {
+ let context = DevToolsCommandContext {
+ protocol: DevToolsProtocol::WebDriverClassic,
+ session_id: Some(DevToolsSessionId::from(session_id)),
+ target_id: Some(DevToolsTargetId::from(target_id)),
+ browser_context_id: None,
+ };
+ ensure_classic_command_page_is_current(scheduler, &context, expected_page)?;
+ match scheduler
+ .execute_devtools_command_with_external_load_wait(
+ receivers,
+ DevToolsCommand::GetFrameTree(DevToolsGetFrameTreeCommand {
+ context,
+ max_depth: None,
+ }),
+ )
+ .await
+ {
+ Ok(DevToolsCommandResult::GetFrameTree(result)) => Ok(result.frame_tree),
+ Ok(_) => Err(DevToolsError::new(
+ DevToolsErrorKind::Internal,
+ "UnexpectedFrameTreeResult",
+ )),
+ Err(error) => Err(error),
+ }
+}
+
+fn ensure_classic_command_page_is_current(
+ scheduler: &mut CdpScheduler,
+ context: &DevToolsCommandContext,
+ expected_page: &DevToolsPageResidenceIdentity,
+) -> Result<(), DevToolsError> {
+ if scheduler.page_residence_identity_for_devtools_context(context)
+ == Some(expected_page.clone())
+ {
+ Ok(())
+ } else {
+ Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchNode,
+ "DOM reference belongs to a replaced Page",
+ ))
+ }
+}
+
fn classic_child_frames_for_frame_id<'a>(
frame_tree: &'a serde_json::Value,
frame_id: &str,
@@ -1726,38 +1888,6 @@ async fn classic_session_ingest_ready_renderer_publications(
mod tests {
use super::*;
- fn classic_binding_for_test() -> ClassicSessionBinding {
- let (tx, _rx) = mpsc::unbounded_channel();
- ClassicSessionBinding {
- session_id: "classic-session".to_owned(),
- target_id: "target-1".to_owned(),
- current_frame_id: None,
- timeouts: ClassicTimeouts::default(),
- page_load_strategy: ClassicPageLoadStrategy::default(),
- unhandled_prompt_behavior: ClassicUnhandledPromptBehavior::default(),
- runtime: ClassicSessionRuntimeHandle { tx },
- }
- }
-
- #[test]
- fn element_registry_resolves_registered_backend_reference_without_id_guessing() {
- let mut manager = ClassicSessionManager::default();
- let binding = classic_binding_for_test();
- let backend_node_id = 2_000_000_042;
- let element_id = manager.register_element_reference(
- &binding,
- backend_node_id,
- DevToolsDomNodeReference::BackendNodeId(backend_node_id),
- );
-
- assert_eq!(
- manager
- .resolve_element_reference(&binding, &element_id)
- .expect("registered element should resolve"),
- DevToolsDomNodeReference::BackendNodeId(backend_node_id)
- );
- }
-
#[test]
fn frame_owner_matching_keeps_frontend_and_backend_ids_disjoint() {
let owner = DevToolsGetFrameOwnerResult {
diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rs
index deb2113bc..ce24a2fe5 100644
--- a/moli-protocol/src/conn.rs
+++ b/moli-protocol/src/conn.rs
@@ -517,11 +517,11 @@ pub(crate) use site_data_manager_surface::{
BrowserContextReservedSiteDataOwnerState, BrowserContextSiteDataManagerOwnerState,
};
pub use state::{
- BackgroundTarget, BrowserContext, BrowserWindowBounds, DocumentStartScript, DownloadNavigation,
- EmulatedDeviceMetrics, EmulatedGeolocationOverride, EmulatedGeolocationOverrideState,
- EmulatedMediaOverrides, IsolatedWorldDefinition, LoadedNavigation, NavigationDispatchState,
- NavigationLoadOutcome, NavigationRequestLoadPolicy, PageNavigationHistoryEntry,
- ParkedFetchState, ParkedNetworkArtifacts, ParkedPageSessionState,
+ BackgroundTarget, BrowserContext, BrowserWindowBounds, DevToolsPageResidenceIdentity,
+ DocumentStartScript, DownloadNavigation, EmulatedDeviceMetrics, EmulatedGeolocationOverride,
+ EmulatedGeolocationOverrideState, EmulatedMediaOverrides, IsolatedWorldDefinition,
+ LoadedNavigation, NavigationDispatchState, NavigationLoadOutcome, NavigationRequestLoadPolicy,
+ PageNavigationHistoryEntry, ParkedFetchState, ParkedNetworkArtifacts, ParkedPageSessionState,
PendingNavigationHistoryUpdate, RuntimeBindingDefinition, TargetInfo, URL_BASE,
};
pub(crate) use state::{
@@ -2035,7 +2035,9 @@ impl CdpConnection {
context: &DevToolsCommandContext,
) -> Option<CommandOwnerScope> {
if let Some(target_id) = context.target_id.as_ref() {
- let route = self.target_session_route_for_target_id(target_id.as_str())?;
+ let route = self
+ .target_session_route_for_target_id(target_id.as_str())
+ .or_else(|| self.target_session_route_for_child_frame_id(target_id.as_str()))?;
return Some(CommandOwnerScope::from_session_and_owner_route(
None,
Some(route),
@@ -2050,6 +2052,21 @@ impl CdpConnection {
))
}
+ /// Captures the exact target Page currently addressed by a protocol-neutral
+ /// command context. The identity remains stable across Document replacement
+ /// within that Page and changes when the Page itself is replaced.
+ pub fn page_residence_identity_for_devtools_context(
+ &mut self,
+ context: &DevToolsCommandContext,
+ ) -> Option<DevToolsPageResidenceIdentity> {
+ let owner_scope = self.command_owner_scope_for_devtools_context(context)?;
+ let session_id = owner_scope.session_id().map(str::to_owned);
+ let mut route_scope = owner_scope.enter(self);
+ route_scope
+ .conn_mut()
+ .target_page_residence_identity_for_session(session_id.as_deref())
+ }
+
pub fn capture_devtools_document_lifecycle_wait_key(
&mut self,
context: &DevToolsCommandContext,
diff --git a/moli-protocol/src/conn/state/attachment_identity.rs b/moli-protocol/src/conn/state/attachment_identity.rs
index 0bb652384..163b7770f 100644
--- a/moli-protocol/src/conn/state/attachment_identity.rs
+++ b/moli-protocol/src/conn/state/attachment_identity.rs
@@ -11,7 +11,7 @@ static NEXT_NAVIGATION_REQUEST_ID: AtomicU64 = AtomicU64::new(1);
/// The id is allocated when renderer Page construction is reserved and remains
/// stable when that exact Page is installed. It also keys the attachment's
/// directly terminable residence token.
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub(crate) struct TargetPageAttachmentId(NonZeroU64);
impl TargetPageAttachmentId {
diff --git a/moli-protocol/src/conn/state/identity.rs b/moli-protocol/src/conn/state/identity.rs
index 378d2cf10..374eab945 100644
--- a/moli-protocol/src/conn/state/identity.rs
+++ b/moli-protocol/src/conn/state/identity.rs
@@ -78,8 +78,8 @@ impl RendererPageResidenceIdentity {
/// so work emitted before installation and work emitted after commit retain the
/// same identity without predicting a numeric generation. A target without a
/// current or reserved Page has no Page residence identity.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct TargetPageResidenceIdentity {
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct TargetPageResidenceIdentity {
browser_context_id: String,
target_id: Option<String>,
page_attachment_id: TargetPageAttachmentId,
diff --git a/moli-protocol/src/conn/state/mod.rs b/moli-protocol/src/conn/state/mod.rs
index 66e655b1b..fc255759d 100644
--- a/moli-protocol/src/conn/state/mod.rs
+++ b/moli-protocol/src/conn/state/mod.rs
@@ -31,6 +31,7 @@ mod tests;
// Re-export everything so `use super::state::*` paths continue to work.
pub(crate) use attachment_identity::{NavigationRequestId, TargetPageAttachmentId};
+pub use identity::TargetPageResidenceIdentity as DevToolsPageResidenceIdentity;
pub use identity::URL_BASE;
pub(crate) use identity::{
RendererPageResidenceIdentity, TargetIdentityState, TargetPageProtocolAttachmentIdentity,
diff --git a/moli-protocol/src/lib.rs b/moli-protocol/src/lib.rs
index d15f7d263..787593f74 100644
--- a/moli-protocol/src/lib.rs
+++ b/moli-protocol/src/lib.rs
@@ -28,8 +28,9 @@ pub use conn::{
DeferredMainDocumentLoadCompletionOutputInterest, DeferredMainDocumentLoadObservationId,
DeferredMainDocumentLoadPredecessorCandidate, DevToolsCommandDispatchOutcome,
DevToolsDocumentLifecycleWaitKey, DevToolsDocumentLifecycleWaitState,
- DevToolsDocumentNavigationState, ParsedCdpCommand, PendingCdpCommandDispatch,
- PendingDeferredMainDocumentLoadCompletion, PendingRuntimeProtocolMessageDispatch,
+ DevToolsDocumentNavigationState, DevToolsPageResidenceIdentity, ParsedCdpCommand,
+ PendingCdpCommandDispatch, PendingDeferredMainDocumentLoadCompletion,
+ PendingRuntimeProtocolMessageDispatch,
};
pub use domains::activity::{
ProtocolSchedulerWork, ProtocolSchedulerWorkKind, ProtocolWorkPublishSequence,
diff --git a/moli-webdriver-smoke/moli_webdriver_smoke/groups/classic.py b/moli-webdriver-smoke/moli_webdriver_smoke/groups/classic.py
index 820245ff0..a07ce3b0f 100644
--- a/moli-webdriver-smoke/moli_webdriver_smoke/groups/classic.py
+++ b/moli-webdriver-smoke/moli_webdriver_smoke/groups/classic.py
@@ -513,6 +513,10 @@ async def _run_input_navigation_replacement_smoke(
"Classic input action responds across Page replacement",
)
await _wait_for_current_url(client, session_id, destination)
+ _assert_classic_stale_element(
+ lambda: client.get(f"/session/{session_id}/element/{field_id}/name"),
+ "Classic input-navigation source element after Page replacement",
+ )
assert_true(
"input navigation complete" in classic_value(client.get(f"/session/{session_id}/source")),
"Classic input action replacement Page remains usable",