Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor(input): centralize editing and native element clicks

ldm01933cec74f5c
diff --git a/moli-core/src/page/command_dispatch.rs b/moli-core/src/page/command_dispatch.rs
index f29102a98..a10a83629 100644
--- a/moli-core/src/page/command_dispatch.rs
+++ b/moli-core/src/page/command_dispatch.rs
@@ -273,6 +273,8 @@ impl Page {
pub(super) fn page_reply_kind(reply: &RendererPageReply) -> &'static str {
match reply {
RendererPageReply::RuntimeEvaluationResult(_) => "a runtime evaluation result reply",
+ RendererPageReply::ElementClickPreparation(_) => "an element click preparation reply",
+ RendererPageReply::ElementClickDispatch(_) => "an element click dispatch reply",
RendererPageReply::Bool(_) => "a bool reply",
RendererPageReply::OptionalBool(_) => "an optional bool reply",
RendererPageReply::InputDispatchOutcome(_) => "an input dispatch outcome reply",
diff --git a/moli-core/src/page/input_support.rs b/moli-core/src/page/input_support.rs
index 93dd02071..0415a6b38 100644
--- a/moli-core/src/page/input_support.rs
+++ b/moli-core/src/page/input_support.rs
@@ -519,3 +519,39 @@ impl PageInputExt for Page {
.await
}
}
+
+impl Page {
+ pub fn start_prepare_element_click(
+ &self,
+ inspector_session_id: Option<String>,
+ object_id: String,
+ ) -> Result<PendingPageCommand> {
+ self.start_page_command(RendererPageCommand::prepare_element_click(
+ inspector_session_id,
+ object_id,
+ ))
+ }
+
+ pub fn start_dispatch_prepared_element_click(
+ &self,
+ click: super::RendererPreparedPointerClick,
+ ) -> Result<PendingPageCommand> {
+ self.start_page_command(RendererPageCommand::DispatchPreparedElementClick(click))
+ }
+}
+
+#[doc(hidden)]
+pub fn decode_element_click_preparation_completion(
+ completion: RendererCommandTurnCompletion,
+) -> Result<Result<super::RendererElementClickTarget, super::RendererElementClickError>> {
+ expect_page_reply!(settled_input_reply(completion)?, "prepare element click", "element click preparation",
+ RendererPageReply::ElementClickPreparation(preparation) => Ok(preparation))
+}
+
+#[doc(hidden)]
+pub fn decode_element_click_dispatch_completion(
+ completion: RendererCommandTurnCompletion,
+) -> Result<Result<RendererInputDispatchOutcome, super::RendererElementClickError>> {
+ expect_page_reply!(settled_input_reply(completion)?, "dispatch element click", "element click dispatch",
+ RendererPageReply::ElementClickDispatch(outcome) => Ok(outcome))
+}
diff --git a/moli-core/src/page/mod.rs b/moli-core/src/page/mod.rs
index 869e8862a..c0ef0acd6 100644
--- a/moli-core/src/page/mod.rs
+++ b/moli-core/src/page/mod.rs
@@ -64,7 +64,9 @@ pub use dom_protocol_support::{
RENDERER_BACKEND_NODE_ID_START, is_renderer_backend_node_id,
};
pub use input_support::{
- PageInputExt, decode_input_dispatch_outcome_completion, decode_insert_text_completion,
+ PageInputExt, decode_element_click_dispatch_completion,
+ decode_element_click_preparation_completion, decode_input_dispatch_outcome_completion,
+ decode_insert_text_completion,
};
pub use moli_page_types::DomScrollIntoViewRect;
pub use moli_page_types::{
@@ -140,6 +142,9 @@ pub use moli_renderer_v8::{
RendererAppManifestQueryResult, RendererAppManifestRelatedApplication,
RendererAppManifestShortcut, RendererPreparedAppManifestLoad,
};
+pub use moli_renderer_v8::{
+ RendererElementClickError, RendererElementClickTarget, RendererPreparedPointerClick,
+};
pub use navigation_diagnostics::{NavigationRedirect, NavigationResponse};
pub use protocol_support::{
BidiPreloadChannelHandoff, ChildFrameAttachmentSnapshot, ChildFrameDetachmentSnapshot,
diff --git a/moli-protocol-server/src/protocol_server/webdriver_classic.rs b/moli-protocol-server/src/protocol_server/webdriver_classic.rs
index 86b8753bd..7a6af3962 100644
--- a/moli-protocol-server/src/protocol_server/webdriver_classic.rs
+++ b/moli-protocol-server/src/protocol_server/webdriver_classic.rs
@@ -11,19 +11,20 @@ use axum::{
http::StatusCode,
response::Response,
};
-use moli_core::page::RendererDocumentLifecycleMilestone;
+use moli_core::page::{
+ RendererDocumentLifecycleMilestone, RendererElementClickError, RendererElementClickTarget,
+};
use moli_html_input_type::InputType;
use moli_protocol::{
DevToolsPageResidenceIdentity,
devtools_runtime::{
- DevToolsCommand, DevToolsCommandContext, DevToolsCommandResult, DevToolsDomGeometryCommand,
- DevToolsDomGeometryOperation, DevToolsDomGeometryResult, DevToolsDomNodeReference,
- DevToolsDownloadBehaviorSetting, DevToolsError, DevToolsErrorKind, DevToolsFrameId,
- DevToolsGetFrameOwnerCommand, DevToolsGetFrameOwnerResult,
- DevToolsGetNodeForLocationCommand, DevToolsGetRealmsCommand, DevToolsGetRealmsResult,
- DevToolsGetServiceWorkerLogsCommand, DevToolsGetServiceWorkerLogsResult,
- DevToolsGetTargetsCommand, DevToolsGetTargetsResult, DevToolsLayoutMetricsResult,
- DevToolsLocateNodesResult, DevToolsMouseEventType, DevToolsProtocol,
+ DevToolsCommand, DevToolsCommandContext, DevToolsCommandResult, DevToolsDomGeometryResult,
+ DevToolsDomNodeReference, DevToolsDownloadBehaviorSetting, DevToolsElementClickCommand,
+ DevToolsElementClickOperation, DevToolsError, DevToolsErrorKind, DevToolsFrameId,
+ DevToolsGetFrameOwnerCommand, DevToolsGetFrameOwnerResult, DevToolsGetRealmsCommand,
+ DevToolsGetRealmsResult, DevToolsGetServiceWorkerLogsCommand,
+ DevToolsGetServiceWorkerLogsResult, DevToolsGetTargetsCommand, DevToolsGetTargetsResult,
+ DevToolsLayoutMetricsResult, DevToolsLocateNodesResult, DevToolsProtocol,
DevToolsQuerySelectorResult, DevToolsRemoteHandleId, DevToolsRemoteValue,
DevToolsScriptException, DevToolsScriptResult, DevToolsSessionId,
DevToolsSetDownloadBehaviorCommand, DevToolsSetFileInputFilesCommand, DevToolsTargetId,
@@ -36,19 +37,18 @@ use moli_protocol_webdriver_classic::{
CLASSIC_WINDOW_REFERENCE_KEY, ClassicDevToolsCommandContext,
ClassicElementOriginViewportPoints, ClassicError, ClassicErrorCode, ClassicPageLoadStrategy,
ClassicPromptHandler, ClassicUnhandledPromptBehavior, ClassicViewportBounds,
- ClassicViewportPoint, action_element_origin_ids, active_element_command, alert_handle_command,
- alert_text_command, classic_attribute_value, classic_error_from_devtools_error,
- classic_property_value, classic_rect_from_geometry, classic_shadow_root_reference,
- classic_text_value, clear_element_command, create_initial_target_command, current_url_command,
+ action_element_origin_ids, active_element_command, alert_handle_command, alert_text_command,
+ classic_attribute_value, classic_error_from_devtools_error, classic_property_value,
+ classic_rect_from_geometry, classic_shadow_root_reference, classic_text_value,
+ clear_element_command, create_initial_target_command, current_url_command,
delete_session_response, describe_node_command, describe_node_reference_command,
element_center_from_geometry, element_click_command, element_click_input_commands,
- element_click_preflight_command, element_click_prepare_reference_commands,
- element_screenshot_command, element_send_keys_input_commands,
- element_send_keys_prepare_text_control_command, element_send_keys_text, execute_async_command,
- execute_sync_command, find_element_command, find_element_command_with_root,
- get_element_attributes_reference_command, get_element_computed_label_command,
- get_element_computed_role_command, get_element_css_value_command,
- get_element_displayed_command, get_element_enabled_command,
+ element_geometry_prepare_commands, element_screenshot_command,
+ element_send_keys_input_commands, element_send_keys_prepare_text_control_command,
+ element_send_keys_text, execute_async_command, execute_sync_command, find_element_command,
+ find_element_command_with_root, get_element_attributes_reference_command,
+ get_element_computed_label_command, get_element_computed_role_command,
+ get_element_css_value_command, get_element_displayed_command, get_element_enabled_command,
get_element_property_reference_command, get_element_rect_reference_command,
get_element_rendered_text_command, get_element_text_reference_command, history_traversal_entry,
layout_metrics_command, matched_capabilities_from_new_session_params, navigate_command,
@@ -4518,156 +4518,29 @@ async fn webdriver_classic_prepare_text_control_for_send_keys(
}
}
-enum ClassicClickPreparation {
- Dom,
- Pointer {
- point: ClassicViewportPoint,
- viewport: ClassicViewportBounds,
- },
-}
-
-impl ClassicClickPreparation {
- fn from_value(value: Value) -> Result<Self, ClassicError> {
- match value.get("status").and_then(Value::as_str) {
- Some("option" | "dom") => Ok(Self::Dom),
- Some("file") => Err(ClassicError::new(
- ClassicErrorCode::InvalidArgument,
- "file inputs cannot be clicked by WebDriver",
- )),
- Some("not interactable") => Err(ClassicError::new(
- ClassicErrorCode::ElementNotInteractable,
- "element has no in-view clickable rectangle",
- )),
- Some("intercepted") => Err(ClassicError::new(
- ClassicErrorCode::ElementClickIntercepted,
- "another element obscures the element's in-view center",
- )),
- Some("pointer") => {
- let coordinate = |name: &str| {
- value
- .get(name)
- .and_then(Value::as_f64)
- .filter(|value| value.is_finite())
- .ok_or_else(|| {
- ClassicError::new(
- ClassicErrorCode::UnknownError,
- format!("click preflight has invalid {name}"),
- )
- })
- };
- let point = ClassicViewportPoint::new(coordinate("x")?, coordinate("y")?)?;
- let viewport = ClassicViewportBounds {
- width: coordinate("viewport_width")?,
- height: coordinate("viewport_height")?,
- };
- if viewport.width <= 0.0 || viewport.height <= 0.0 {
- return Err(ClassicError::new(
- ClassicErrorCode::ElementNotInteractable,
- "frame has an empty viewport",
- ));
- }
- Ok(Self::Pointer { point, viewport })
- }
- _ => Err(ClassicError::new(
- ClassicErrorCode::UnknownError,
- "element click preflight returned an invalid status",
- )),
- }
- }
-}
-
-async fn webdriver_classic_click_point(
- binding: &ClassicSessionBinding,
- point: ClassicViewportPoint,
- viewport: ClassicViewportBounds,
-) -> Result<ClassicViewportPoint, ClassicError> {
- let Some(frame_id) = binding.current_frame_id.as_deref() else {
- return ClassicViewportPoint::new(point.x, point.y);
- };
- let owner = classic_frame_owner_dom_reference(binding, frame_id).await?;
- let result = binding
- .runtime
- .execute_on_page(
- DevToolsCommand::DomGeometry(DevToolsDomGeometryCommand {
- context: classic_top_level_devtools_context(binding),
- reference: owner.reference,
- operation: DevToolsDomGeometryOperation::GetBoxModel,
- }),
- owner.page_residence.clone(),
- )
- .await
- .map_err(classic_error_from_devtools_error)?;
- let DevToolsCommandResult::DomGeometry(geometry) = result else {
- return Err(ClassicError::new(
- ClassicErrorCode::UnknownError,
- "frame geometry returned an unexpected result",
- ));
- };
- let model = geometry.box_model.ok_or_else(|| {
- ClassicError::new(
+fn classic_error_from_click_preparation(error: RendererElementClickError) -> ClassicError {
+ let (code, message) = match error {
+ RendererElementClickError::StaleNode => (
+ ClassicErrorCode::StaleElementReference,
+ "element no longer belongs to the current document".to_owned(),
+ ),
+ RendererElementClickError::MissingBrowsingContext => (
+ ClassicErrorCode::NoSuchWindow,
+ "element browsing context is no longer available".to_owned(),
+ ),
+ RendererElementClickError::NoClickableRect => (
ClassicErrorCode::ElementNotInteractable,
- "frame has no content geometry",
- )
- })?;
- let [x0, y0, x1, y1, _, _, x3, y3] = model.content.points.as_slice() else {
- return Err(ClassicError::new(
- ClassicErrorCode::UnknownError,
- "frame has invalid content geometry",
- ));
- };
- // The content quad already includes every ancestor-frame transform. Map
- // the exact locally hit-tested point, retaining rotation/scale and borders.
- let u = point.x / viewport.width;
- let v = point.y / viewport.height;
- let point = ClassicViewportPoint::new(
- x0 + u * (x1 - x0) + v * (x3 - x0),
- y0 + u * (y1 - y0) + v * (y3 - y0),
- )?;
- // Use the renderer's deep hit path, which enters a child document only
- // when each ancestor frame owner is actually visible at this root point.
- let hit = binding
- .runtime
- .execute_on_page(
- DevToolsCommand::GetNodeForLocation(DevToolsGetNodeForLocationCommand {
- context: classic_top_level_devtools_context(binding),
- x: point.x,
- y: point.y,
- include_user_agent_shadow_dom: false,
- ignore_pointer_events_none: false,
- }),
- owner.page_residence,
- )
- .await
- .map_err(classic_error_from_devtools_error)?;
- let DevToolsCommandResult::GetNodeForLocation(hit) = hit else {
- return Err(ClassicError::new(
- ClassicErrorCode::UnknownError,
- "frame hit test returned an unexpected result",
- ));
- };
- // Local preflight already requires the hit element to be in the target's
- // subtree. A target iframe (or its container) can legitimately lead the
- // deep hit into another document, so require the hit path to pass through
- // the current frame, not to end there. Ancestor/sibling overlays fail this.
- let mut hit_frame_id = Some(hit.frame_id.as_str().to_owned());
- while let Some(hit_frame) = hit_frame_id {
- if hit_frame == frame_id {
- return Ok(point);
+ "element has no in-view clickable rectangle".to_owned(),
+ ),
+ RendererElementClickError::Obscured => (
+ ClassicErrorCode::ElementClickIntercepted,
+ "another element obscures the element's in-view center".to_owned(),
+ ),
+ RendererElementClickError::LayoutUnavailable(message) => {
+ (ClassicErrorCode::UnknownError, message)
}
- hit_frame_id = binding
- .runtime
- .parent_frame_id(
- binding.session_id.clone(),
- binding.target_id.clone(),
- hit_frame,
- )
- .await
- .map_err(classic_error_from_devtools_error)?;
- }
- Err(ClassicError::new(
- ClassicErrorCode::ElementClickIntercepted,
- "an ancestor document obscures the target frame's click point",
- ))
+ };
+ ClassicError::new(code, message)
}
async fn webdriver_classic_activate_element_by_handle(
@@ -4690,33 +4563,33 @@ async fn webdriver_classic_activate_element_by_handle(
let prepared = binding
.runtime
.execute_on_page(
- element_click_preflight_command(
- context,
- object_id.object_id.clone(),
- state.layout_policy.uses_real_layout(),
- ),
+ DevToolsCommand::ElementClick(DevToolsElementClickCommand {
+ context: classic_top_level_devtools_context(binding),
+ operation: DevToolsElementClickOperation::Prepare {
+ object_id: object_id.object_id.clone().into(),
+ },
+ }),
object_id.page_residence.clone(),
)
.await;
let preparation = match prepared {
- Ok(DevToolsCommandResult::Script(result)) => match *result {
- DevToolsScriptResult::Value(value) => ClassicClickPreparation::from_value(value.value),
- DevToolsScriptResult::Exception(exception) => {
- Err(classic_webdriver_command_exception_error(exception))
- }
- },
+ Ok(DevToolsCommandResult::ElementClickPreparation(result)) => {
+ result.map_err(classic_error_from_click_preparation)
+ }
Ok(_) => Err(ClassicError::new(
ClassicErrorCode::UnknownError,
- "element click preflight returned an unexpected result",
+ "element click preparation returned an unexpected result",
)),
Err(error) => Err(classic_error_from_devtools_error(error)),
};
let mut activation_dispatched = false;
- let mut pointer_press_completed = false;
let operation = async {
- let preparation = preparation?;
- match preparation {
- ClassicClickPreparation::Dom => {
+ match preparation? {
+ RendererElementClickTarget::FileInput => Err(ClassicError::new(
+ ClassicErrorCode::InvalidArgument,
+ "file inputs cannot be clicked by WebDriver",
+ )),
+ RendererElementClickTarget::DomActivation | RendererElementClickTarget::Option => {
activation_dispatched = true;
Ok(binding
.runtime
@@ -4726,33 +4599,26 @@ async fn webdriver_classic_activate_element_by_handle(
)
.await)
}
- ClassicClickPreparation::Pointer { point, viewport } => {
- let point = webdriver_classic_click_point(binding, point, viewport).await?;
- // The preflight point has been mapped into the root viewport.
- let pointer_context = classic_top_level_context(binding);
- let commands = element_click_input_commands(&pointer_context, point);
- let mut result = Ok(DevToolsCommandResult::Empty);
- for command in commands {
- let event_type = match &command {
- DevToolsCommand::DispatchMouseEvent(event) => Some(event.event_type),
- _ => None,
- };
- activation_dispatched = event_type == Some(DevToolsMouseEventType::Released);
- // Do not retry an input command or wait for navigation
- // between pointer phases. Page residence is not a promise
- // that the active Document cannot change during input.
- result = binding
- .runtime
- .execute_on_page(command, object_id.page_residence.clone())
- .await;
- if !matches!(result, Ok(DevToolsCommandResult::Empty)) {
- break;
- }
- if event_type == Some(DevToolsMouseEventType::Pressed) {
- pointer_press_completed = true;
+ RendererElementClickTarget::Pointer(click) => {
+ activation_dispatched = true;
+ // The renderer validates document ownership before move and
+ // between phases. No phase can be retried on a successor.
+ let result = binding
+ .runtime
+ .execute_on_page(
+ DevToolsCommand::ElementClick(DevToolsElementClickCommand {
+ context: classic_top_level_devtools_context(binding),
+ operation: DevToolsElementClickOperation::Dispatch(click),
+ }),
+ object_id.page_residence.clone(),
+ )
+ .await;
+ match result {
+ Ok(DevToolsCommandResult::ElementClickDispatch(Err(error))) => {
+ Err(classic_error_from_click_preparation(error))
}
+ result => Ok(result),
}
- Ok(result)
}
}
}
@@ -4761,7 +4627,7 @@ async fn webdriver_classic_activate_element_by_handle(
let result = operation?;
let post_click_navigation = classic_wait_for_current_document(binding).await;
match result {
- Ok(DevToolsCommandResult::Empty) => {
+ Ok(DevToolsCommandResult::Empty | DevToolsCommandResult::ElementClickDispatch(Ok(()))) => {
post_click_navigation?;
if binding.current_frame_id.is_some()
&& let Err(error) = ensure_classic_current_browsing_context_exists(binding).await
@@ -4823,18 +4689,7 @@ async fn webdriver_classic_activate_element_by_handle(
// Chromium references:
// chrome/test/chromedriver/element_commands.cc (ExecuteClickElement)
// chrome/test/chromedriver/window_commands.cc (ExecuteWindowCommand)
- // A completed mousedown can replace the Page before the queued
- // mouseup is admitted. The page-bound guard then rejects that phase
- // before dispatch, rather than losing the renderer response. Both
- // outcomes must leave the successor untouched. Require a completed
- // pointer press so preflight/option stale handles remain errors.
- Err(error)
- if activation_dispatched
- && (error.message == "Renderer attachment changed"
- || (pointer_press_completed
- && error.kind == DevToolsErrorKind::NoSuchNode
- && error.message == "DOM reference belongs to a replaced Page")) =>
- {
+ Err(error) if activation_dispatched && error.message == "Renderer attachment changed" => {
post_click_navigation
}
Err(error) => Err(classic_error_from_devtools_error(error)),
@@ -4967,7 +4822,7 @@ async fn webdriver_classic_element_geometry(
) -> Result<DevToolsDomGeometryResult, ClassicError> {
let reference = resolve_classic_element_dom_reference(state, binding, element_id)?;
let page_residence = reference.page_residence;
- let commands = element_click_prepare_reference_commands(context, reference.reference);
+ let commands = element_geometry_prepare_commands(context, reference.reference);
let mut geometry = None;
for command in commands {
match binding
diff --git a/moli-protocol-webdriver-bidi/src/responses.rs b/moli-protocol-webdriver-bidi/src/responses.rs
index f14e3c53c..f1a516ab8 100644
--- a/moli-protocol-webdriver-bidi/src/responses.rs
+++ b/moli-protocol-webdriver-bidi/src/responses.rs
@@ -39,6 +39,17 @@ pub fn error_response(id: Option<u64>, code: BidiErrorCode, message: &str) -> Va
}
pub fn bidi_response_from_devtools_result(id: u64, result: DevToolsCommandResult) -> Value {
+ if matches!(
+ result,
+ DevToolsCommandResult::ElementClickPreparation(_)
+ | DevToolsCommandResult::ElementClickDispatch(_)
+ ) {
+ return error_response(
+ Some(id),
+ BidiErrorCode::UnsupportedOperation,
+ "element click results are internal to WebDriver Classic",
+ );
+ }
if matches!(result, DevToolsCommandResult::GetNodeForLocation(_)) {
return error_response(
Some(id),
@@ -75,6 +86,10 @@ pub fn bidi_response_from_devtools_error(id: u64, error: DevToolsError) -> Value
fn bidi_result_payload_from_devtools_result(result: DevToolsCommandResult) -> Value {
match result {
+ DevToolsCommandResult::ElementClickPreparation(_)
+ | DevToolsCommandResult::ElementClickDispatch(_) => {
+ unreachable!("element click results have no WebDriver BiDi success projection")
+ }
DevToolsCommandResult::Empty | DevToolsCommandResult::TraverseHistory(_) => json!({}),
DevToolsCommandResult::Navigate(result) => json!({
"navigation": result
diff --git a/moli-protocol-webdriver-classic/src/commands/elements.rs b/moli-protocol-webdriver-classic/src/commands/elements.rs
index fa9c0cb6c..59bba9592 100644
--- a/moli-protocol-webdriver-classic/src/commands/elements.rs
+++ b/moli-protocol-webdriver-classic/src/commands/elements.rs
@@ -737,51 +737,6 @@ pub fn clear_element_command(
})
}
-/// Validate activation without dispatching it. Real-layout sessions use pointer
-/// input; DOM-first sessions retain semantic activation without hit testing.
-pub fn element_click_preflight_command(
- context: &ClassicDevToolsCommandContext,
- object_id: impl Into<String>,
- use_real_layout: bool,
-) -> DevToolsCommand {
- let mut command = element_click_call_function(context, object_id);
- command.function_declaration = r#"function(useRealLayout) {
- if (!this || this.nodeType !== Node.ELEMENT_NODE || !this.isConnected)
- throw new Error('__moli_webdriver_classic_stale_element_reference__');
- if (this.localName === 'input' && this.type === 'file')
- return {status: 'file'};
- // Options have a separate selection algorithm, not a pointer target
- // in the page's rendered select popup.
- if (this.localName === 'option') return {status: 'option'};
- if (!useRealLayout) return {status: 'dom'};
- this.scrollIntoView({block: 'center', inline: 'center', behavior: 'instant'});
- const rect = this.getClientRects()[0];
- if (!rect || rect.width <= 0 || rect.height <= 0)
- return {status: 'not interactable'};
- // WebDriver's in-view center is the clipped first client rectangle,
- // not the bounding box of every fragment. Return the tested point so
- // dispatch cannot recompute a different center.
- const view = this.ownerDocument.defaultView;
- const width = view.innerWidth, height = view.innerHeight;
- const left = Math.max(0, rect.left), right = Math.min(width, rect.right);
- const top = Math.max(0, rect.top), bottom = Math.min(height, rect.bottom);
- if (right <= left || bottom <= top)
- return {status: 'not interactable'};
- const x = Math.floor((left + right) / 2), y = Math.floor((top + bottom) / 2);
- const root = this.getRootNode();
- const hit = (typeof root.elementFromPoint === 'function' ? root : this.ownerDocument)
- .elementFromPoint(x, y);
- if (!hit || !(hit === this || this.contains(hit)))
- return {status: 'intercepted'};
- return {status: 'pointer', x, y, viewport_width: width, viewport_height: height};
- }"#
- .to_owned();
- command.arguments = vec![json!(use_real_layout)];
- command.await_promise = false;
- command.user_gesture = false;
- DevToolsCommand::CallFunction(command)
-}
-
pub fn element_click_command(
context: &ClassicDevToolsCommandContext,
object_id: impl Into<String>,
@@ -847,15 +802,7 @@ fn element_click_call_function(
}
}
-pub fn element_click_prepare_commands(
- context: &ClassicDevToolsCommandContext,
- element_id: &str,
-) -> Result<Vec<DevToolsCommand>, ClassicError> {
- let reference = dom_node_reference_from_classic_element_id(element_id)?;
- Ok(element_click_prepare_reference_commands(context, reference))
-}
-
-pub fn element_click_prepare_reference_commands(
+pub fn element_geometry_prepare_commands(
context: &ClassicDevToolsCommandContext,
reference: DevToolsDomNodeReference,
) -> Vec<DevToolsCommand> {
diff --git a/moli-protocol-webdriver-classic/src/commands/mod.rs b/moli-protocol-webdriver-classic/src/commands/mod.rs
index f720f7fd1..694305e66 100644
--- a/moli-protocol-webdriver-classic/src/commands/mod.rs
+++ b/moli-protocol-webdriver-classic/src/commands/mod.rs
@@ -21,9 +21,8 @@ pub use elements::{
classic_elements_from_query_result, classic_property_value, classic_rect_from_geometry,
classic_shadow_root_id, classic_shadow_root_reference, classic_text_value,
clear_element_command, describe_node_command, describe_node_reference_command,
- element_click_command, element_click_preflight_command, element_click_prepare_commands,
- element_click_prepare_reference_commands, find_element_command, find_element_command_with_root,
- frame_id_for_element_command, get_element_attributes_command,
+ element_click_command, element_geometry_prepare_commands, find_element_command,
+ find_element_command_with_root, frame_id_for_element_command, get_element_attributes_command,
get_element_attributes_reference_command, get_element_computed_label_command,
get_element_computed_role_command, get_element_css_value_command,
get_element_displayed_command, get_element_enabled_command, get_element_property_command,
diff --git a/moli-protocol-webdriver-classic/src/lib.rs b/moli-protocol-webdriver-classic/src/lib.rs
index 89c2880c2..2918cfba6 100644
--- a/moli-protocol-webdriver-classic/src/lib.rs
+++ b/moli-protocol-webdriver-classic/src/lib.rs
@@ -49,8 +49,7 @@ pub use commands::{
classic_text_value, classic_window_rect_for_state, classic_window_rect_from_metrics,
clear_element_command, close_window_command, create_initial_target_command,
current_url_command, delete_all_cookies_command, delete_cookie_command, describe_node_command,
- describe_node_reference_command, element_click_command, element_click_preflight_command,
- element_click_prepare_commands, element_click_prepare_reference_commands,
+ describe_node_reference_command, element_click_command, element_geometry_prepare_commands,
element_screenshot_command, execute_async_command, execute_sync_command, find_element_command,
find_element_command_with_root, frame_id_for_element_command, get_cookies_command,
get_element_attributes_command, get_element_attributes_reference_command,
diff --git a/moli-protocol-webdriver-classic/src/tests.rs b/moli-protocol-webdriver-classic/src/tests.rs
index 0e3427481..8ddd703a3 100644
--- a/moli-protocol-webdriver-classic/src/tests.rs
+++ b/moli-protocol-webdriver-classic/src/tests.rs
@@ -1485,10 +1485,11 @@ fn maps_element_clear_to_shared_dom_resolve_and_runtime_command() {
}
#[test]
-fn maps_element_click_to_shared_dom_geometry_and_input_commands() {
+fn maps_element_geometry_and_coordinate_input_commands() {
let context = ClassicDevToolsCommandContext::with_target_id("classic-session-1", "TID-1");
- let commands = element_click_prepare_commands(&context, "moli-node-23").expect("commands");
+ let commands =
+ element_geometry_prepare_commands(&context, DevToolsDomNodeReference::FrontendNodeId(23));
assert_eq!(commands.len(), 2);
let DevToolsCommand::ScrollIntoViewIfNeeded(scroll) = &commands[0] else {
panic!("expected scroll command");
@@ -1536,10 +1537,6 @@ fn maps_element_click_to_shared_dom_geometry_and_input_commands() {
assert_eq!(command.button, 0);
assert_eq!(command.buttons, buttons);
}
-
- let invalid = element_click_prepare_commands(&context, "not-a-moli-node")
- .expect_err("invalid element id should fail");
- assert_eq!(invalid.code, ClassicErrorCode::NoSuchElement);
}
#[test]
diff --git a/moli-protocol/src/conn/devtools_command.rs b/moli-protocol/src/conn/devtools_command.rs
index 577183c22..d28b926ed 100644
--- a/moli-protocol/src/conn/devtools_command.rs
+++ b/moli-protocol/src/conn/devtools_command.rs
@@ -305,7 +305,8 @@ impl CdpConnection {
crate::domains::network::execute_devtools_network_command(self, command),
Vec::new(),
),
- command @ (DevToolsCommand::DispatchMouseEvent(_)
+ command @ (DevToolsCommand::ElementClick(_)
+ | DevToolsCommand::DispatchMouseEvent(_)
| DevToolsCommand::DispatchKeyEvent(_)
| DevToolsCommand::DispatchTouchEvent(_)
| DevToolsCommand::DispatchDragEvent(_)
diff --git a/moli-protocol/src/devtools_runtime.rs b/moli-protocol/src/devtools_runtime.rs
index b94feadbd..ae87ce3a2 100644
--- a/moli-protocol/src/devtools_runtime.rs
+++ b/moli-protocol/src/devtools_runtime.rs
@@ -269,6 +269,7 @@ pub enum DevToolsCommand {
RemoveNode(DevToolsRemoveNodeCommand),
AddPreloadScript(DevToolsAddPreloadScriptCommand),
RemovePreloadScript(DevToolsRemovePreloadScriptCommand),
+ ElementClick(DevToolsElementClickCommand),
DispatchMouseEvent(DevToolsDispatchMouseEventCommand),
DispatchKeyEvent(DevToolsDispatchKeyEventCommand),
DispatchTouchEvent(DevToolsDispatchTouchEventCommand),
@@ -355,6 +356,7 @@ impl DevToolsCommand {
DevToolsCommand::RemoveNode(command) => &command.context,
DevToolsCommand::AddPreloadScript(command) => &command.context,
DevToolsCommand::RemovePreloadScript(command) => &command.context,
+ DevToolsCommand::ElementClick(command) => &command.context,
DevToolsCommand::DispatchMouseEvent(command) => &command.context,
DevToolsCommand::DispatchKeyEvent(command) => &command.context,
DevToolsCommand::DispatchTouchEvent(command) => &command.context,
@@ -1029,6 +1031,18 @@ pub enum DevToolsDomObjectReferenceOperation {
DescribeNode { depth: i32, pierce: bool },
}
+#[derive(Debug, Clone, PartialEq)]
+pub struct DevToolsElementClickCommand {
+ pub context: DevToolsCommandContext,
+ pub operation: DevToolsElementClickOperation,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum DevToolsElementClickOperation {
+ Prepare { object_id: DevToolsRemoteHandleId },
+ Dispatch(moli_core::page::RendererPreparedPointerClick),
+}
+
#[derive(Debug, Clone, PartialEq)]
pub struct DevToolsDomObjectReferenceCommand {
pub context: DevToolsCommandContext,
@@ -1367,6 +1381,13 @@ pub struct DevToolsFulfillInterceptedRequestCommand {
#[derive(Debug, Clone, PartialEq)]
pub enum DevToolsCommandResult {
+ ElementClickPreparation(
+ Result<
+ moli_core::page::RendererElementClickTarget,
+ moli_core::page::RendererElementClickError,
+ >,
+ ),
+ ElementClickDispatch(Result<(), moli_core::page::RendererElementClickError>),
Empty,
Navigate(DevToolsNavigateResult),
TraverseHistory(DevToolsTraverseHistoryResult),
diff --git a/moli-protocol/src/domains/command_output.rs b/moli-protocol/src/domains/command_output.rs
index dec5db6b2..0ad537d3b 100644
--- a/moli-protocol/src/domains/command_output.rs
+++ b/moli-protocol/src/domains/command_output.rs
@@ -1607,6 +1607,10 @@ fn blocked_intercepts_from_cdp_params(params: &Value) -> Vec<DevToolsNetworkInte
fn cdp_result_payload_from_devtools_result(result: DevToolsCommandResult) -> Value {
match result {
+ DevToolsCommandResult::ElementClickPreparation(_)
+ | DevToolsCommandResult::ElementClickDispatch(_) => {
+ unreachable!("element click is an internal automation operation with no CDP method")
+ }
DevToolsCommandResult::Empty | DevToolsCommandResult::TraverseHistory(_) => json!({}),
DevToolsCommandResult::Navigate(result) => {
let mut payload = json!({});
diff --git a/moli-protocol/src/domains/input.rs b/moli-protocol/src/domains/input.rs
index 9b82692f2..fd3ba4df0 100644
--- a/moli-protocol/src/domains/input.rs
+++ b/moli-protocol/src/domains/input.rs
@@ -6,8 +6,8 @@ use crate::devtools_runtime::{
DevToolsCommand, DevToolsCommandContext, DevToolsCommandResult,
DevToolsDispatchDragEventCommand, DevToolsDispatchKeyEventCommand,
DevToolsDispatchMouseEventCommand, DevToolsDispatchTouchEventCommand, DevToolsDragData,
- DevToolsDragDataItem, DevToolsDragEventType, DevToolsError, DevToolsErrorKind,
- DevToolsKeyEventType, DevToolsMouseEventType, DevToolsPointerType,
+ DevToolsDragDataItem, DevToolsDragEventType, DevToolsElementClickOperation, DevToolsError,
+ DevToolsErrorKind, DevToolsKeyEventType, DevToolsMouseEventType, DevToolsPointerType,
DevToolsSynthesizeTapGestureCommand, DevToolsTouchEventType, DevToolsTouchPoint,
};
use crate::domains::command_output::CommandOutputPlan;
@@ -15,7 +15,8 @@ use moli_core::page::{
CompletedPageCommand, Page, PageInputExt, PendingPageCommand, RendererCommandTurnCompletion,
RendererDragData, RendererDragDataItem, RendererDraggedFile, RendererInputDispatchOutcome,
RendererPendingDownloadActivation, RendererPendingFileChooserActivation,
- RendererPointerEventProperties, RendererTouchPoint, decode_input_dispatch_outcome_completion,
+ RendererPointerEventProperties, RendererTouchPoint, decode_element_click_dispatch_completion,
+ decode_element_click_preparation_completion, decode_input_dispatch_outcome_completion,
decode_insert_text_completion,
};
use serde::Deserialize;
@@ -122,6 +123,8 @@ struct PendingInputCommandStartError {
#[derive(Clone)]
enum PendingInputCommandKind {
+ PrepareElementClick,
+ DispatchElementClick,
DispatchMouseEvent,
DispatchKeyEvent,
DispatchTouchEvent,
@@ -242,7 +245,10 @@ impl PendingInputCommandKind {
// Chromium's InputInjector owns replacement cleanup for the mouse and
// key callback queues. Touch, drag, and IME commands have separate
// completion protocols and must keep waiting for those terminals.
- matches!(self, Self::DispatchMouseEvent | Self::DispatchKeyEvent)
+ matches!(
+ self,
+ Self::DispatchMouseEvent | Self::DispatchKeyEvent | Self::DispatchElementClick
+ )
}
}
@@ -565,6 +571,15 @@ fn start_input_command_dispatch_after_noop_checks(
}
}
+fn key_event_targets_outgoing_document(
+ conn: &CdpConnection,
+ owner: &CommandOwnerScope,
+ event_type: DevToolsKeyEventType,
+) -> bool {
+ event_type == DevToolsKeyEventType::KeyUp
+ && conn.has_pending_document_navigation_for_owner(owner)
+}
+
fn start_pending_input_command(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
@@ -582,10 +597,9 @@ fn start_pending_input_command(
// navigation before Playwright sends the matching keyup. Keep that
// terminal event on the still-attached outgoing Page; every other key
// event retains the normal cross-document navigation gate.
- let targets_outgoing_document = conn.has_pending_document_navigation_for_owner(&owner)
- && parsed_key_event
- .as_ref()
- .is_some_and(|parsed| parsed.event_type == DevToolsKeyEventType::KeyUp);
+ let targets_outgoing_document = parsed_key_event
+ .as_ref()
+ .is_some_and(|parsed| key_event_targets_outgoing_document(conn, &owner, parsed.event_type));
if action.requires_document_access()
&& !targets_outgoing_document
&& let Err(message) = conn.ensure_document_accessible_for_owner(&owner)
@@ -930,6 +944,7 @@ fn devtools_input_command_route(
command: &DevToolsCommand,
) -> Result<(Option<String>, Option<String>), DevToolsError> {
let context = match command {
+ DevToolsCommand::ElementClick(command) => &command.context,
DevToolsCommand::DispatchMouseEvent(command) => &command.context,
DevToolsCommand::DispatchKeyEvent(command) => &command.context,
DevToolsCommand::DispatchTouchEvent(command) => &command.context,
@@ -992,8 +1007,8 @@ fn start_devtools_dispatch_key_event_command(
owner: &CommandOwnerScope,
command: DevToolsDispatchKeyEventCommand,
) -> Result<Option<PendingInputCommandDispatch>, PendingInputCommandStartError> {
- let targets_outgoing_document = command.event_type == DevToolsKeyEventType::KeyUp
- && conn.has_pending_document_navigation_for_owner(owner);
+ let targets_outgoing_document =
+ key_event_targets_outgoing_document(conn, owner, command.event_type);
start_page_input_command_with_access(
conn,
command_id,
@@ -1269,7 +1284,11 @@ fn start_devtools_input_command_for_owner(
command: DevToolsCommand,
) -> Result<Option<PendingInputCommandDispatch>, PendingInputCommandStartError> {
let coordinate_unsupported = match &command {
- DevToolsCommand::DispatchMouseEvent(_) => Some(DISPATCH_MOUSE_EVENT_UNSUPPORTED_MESSAGE),
+ DevToolsCommand::ElementClick(crate::devtools_runtime::DevToolsElementClickCommand {
+ operation: DevToolsElementClickOperation::Dispatch(_),
+ ..
+ })
+ | DevToolsCommand::DispatchMouseEvent(_) => Some(DISPATCH_MOUSE_EVENT_UNSUPPORTED_MESSAGE),
DevToolsCommand::DispatchTouchEvent(_) => Some(DISPATCH_TOUCH_EVENT_UNSUPPORTED_MESSAGE),
DevToolsCommand::DispatchDragEvent(_) => Some(DISPATCH_DRAG_EVENT_UNSUPPORTED_MESSAGE),
DevToolsCommand::SynthesizeTapGesture(_) => {
@@ -1286,6 +1305,27 @@ fn start_devtools_input_command_for_owner(
}
}
match command {
+ DevToolsCommand::ElementClick(command) => match command.operation {
+ DevToolsElementClickOperation::Prepare { object_id } => start_page_input_command(
+ conn,
+ command_id,
+ owner,
+ PendingInputCommandKind::PrepareElementClick,
+ |page| {
+ page.start_prepare_element_click(
+ owner.session_id().map(str::to_owned),
+ object_id.to_string(),
+ )
+ },
+ ),
+ DevToolsElementClickOperation::Dispatch(click) => start_page_input_command(
+ conn,
+ command_id,
+ owner,
+ PendingInputCommandKind::DispatchElementClick,
+ |page| page.start_dispatch_prepared_element_click(click),
+ ),
+ },
DevToolsCommand::DispatchMouseEvent(command) => {
start_devtools_dispatch_mouse_event_command(conn, command_id, owner, command)
}
@@ -1340,6 +1380,51 @@ async fn complete_pending_input_command(
let mut side_effects = InputCommandSideEffects::default();
let result = match completed.kind {
+ kind @ (PendingInputCommandKind::PrepareElementClick
+ | PendingInputCommandKind::DispatchElementClick) => {
+ match completed_page_command_result(completed_operation) {
+ Err(error) => Err(error),
+ Ok(result) => {
+ let completion = settle_completed_input_page_command(
+ conn,
+ session_id,
+ &owner,
+ result,
+ command_context,
+ );
+ if matches!(kind, PendingInputCommandKind::PrepareElementClick) {
+ decode_element_click_preparation_completion(completion)
+ .map(DevToolsCommandResult::ElementClickPreparation)
+ .map_err(|error| {
+ DevToolsError::new(DevToolsErrorKind::Internal, error.to_string())
+ })
+ } else {
+ match decode_element_click_dispatch_completion(completion) {
+ Err(error) => Err(DevToolsError::new(
+ DevToolsErrorKind::Internal,
+ error.to_string(),
+ )),
+ Ok(Err(error)) => {
+ Ok(DevToolsCommandResult::ElementClickDispatch(Err(error)))
+ }
+ Ok(Ok(outcome)) => handle_input_dispatch_outcome_async(
+ conn,
+ &mut side_effects,
+ session_id,
+ &owner,
+ outcome,
+ command_context,
+ )
+ .await
+ .map(|()| DevToolsCommandResult::ElementClickDispatch(Ok(())))
+ .map_err(|error| {
+ DevToolsError::new(DevToolsErrorKind::Internal, error)
+ }),
+ }
+ }
+ }
+ }
+ }
kind @ (PendingInputCommandKind::DispatchMouseEvent
| PendingInputCommandKind::DispatchTouchEvent
| PendingInputCommandKind::DispatchDragEvent
@@ -1366,7 +1451,10 @@ async fn complete_pending_input_command(
PendingInputCommandKind::DispatchTouchEvent
| PendingInputCommandKind::SynthesizeTapGesture => "touch event page command",
PendingInputCommandKind::DispatchDragEvent => "drag event page command",
- PendingInputCommandKind::DispatchKeyEvent | PendingInputCommandKind::InsertText => {
+ PendingInputCommandKind::DispatchKeyEvent
+ | PendingInputCommandKind::InsertText
+ | PendingInputCommandKind::PrepareElementClick
+ | PendingInputCommandKind::DispatchElementClick => {
unreachable!()
}
};
diff --git a/moli-protocol/src/domains/input/tests.rs b/moli-protocol/src/domains/input/tests.rs
index 86084b17a..b3790654a 100644
--- a/moli-protocol/src/domains/input/tests.rs
+++ b/moli-protocol/src/domains/input/tests.rs
@@ -3,6 +3,7 @@ use crate::conn::{BrowserContext, CdpCommandTaskStep, CommandDispatchContext};
use crate::testing::{TestContext, wait_until_frame_stopped_loading};
use moli_core::LayoutPolicy;
+mod element_click;
mod keyboard_events;
const INPUT_HIT_X: u32 = 20;
diff --git a/moli-protocol/src/domains/input/tests/element_click.rs b/moli-protocol/src/domains/input/tests/element_click.rs
new file mode 100644
index 000000000..6b11e2a7a
--- /dev/null
+++ b/moli-protocol/src/domains/input/tests/element_click.rs
@@ -0,0 +1,110 @@
+use super::*;
+use crate::devtools_runtime::{
+ DevToolsElementClickCommand, DevToolsElementClickOperation, DevToolsProtocol,
+};
+use moli_core::page::{
+ RendererElementClickError, RendererElementClickTarget, RendererPreparedPointerClick,
+};
+
+async fn command(
+ ctx: &mut TestContext,
+ operation: DevToolsElementClickOperation,
+) -> DevToolsCommandResult {
+ ctx.conn
+ .execute_devtools_command(DevToolsCommand::ElementClick(DevToolsElementClickCommand {
+ context: DevToolsCommandContext {
+ protocol: DevToolsProtocol::WebDriverClassic,
+ session_id: None,
+ target_id: None,
+ browser_context_id: None,
+ },
+ operation,
+ }))
+ .await
+ .into_parts()
+ .0
+ .expect("native element click command")
+}
+
+async fn prepare(ctx: &mut TestContext) -> RendererPreparedPointerClick {
+ let object_id = resolve_selector_object_id(ctx, "#target", 501).await;
+ match command(
+ ctx,
+ DevToolsElementClickOperation::Prepare {
+ object_id: object_id.into(),
+ },
+ )
+ .await
+ {
+ DevToolsCommandResult::ElementClickPreparation(Ok(
+ RendererElementClickTarget::Pointer(click),
+ )) => click,
+ result => panic!("expected prepared pointer click: {result:?}"),
+ }
+}
+
+async fn fixture() -> TestContext {
+ let mut ctx = TestContext::new();
+ with_loaded_document(&mut ctx, r#"<html><body>
+ <button id='target' style='position:absolute;left:40px;top:40px;width:120px;height:70px'>go</button>
+ <script>
+ window.clicks=0; window.events=[];
+ document.getElementById('target').onclick=()=>clicks++;
+ for(const type of ['mousemove','mousedown','mouseup','click'])
+ document.addEventListener(type,e=>events.push([type,e.target.id]));
+ </script></body></html>"#).await;
+ ctx
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn native_element_click_rejects_stale_preparation_before_observable_input() {
+ for mutation in [
+ "target.remove()",
+ "document.open();document.write('<button id=target>replacement</button>');document.close()",
+ ] {
+ let mut ctx = fixture().await;
+ let click = prepare(&mut ctx).await;
+ assert!(evaluate_bool(&mut ctx, &format!("(()=>{{const target=document.getElementById('target');{mutation};return true}})()")).await);
+ let result = command(&mut ctx, DevToolsElementClickOperation::Dispatch(click)).await;
+ let DevToolsCommandResult::ElementClickDispatch(result) = result else {
+ panic!("unexpected dispatch result: {result:?}")
+ };
+ assert_eq!(
+ result,
+ Err(RendererElementClickError::StaleNode),
+ "{mutation}"
+ );
+ let observed = evaluate_string(&mut ctx, "JSON.stringify([clicks,events])").await;
+ assert_eq!(
+ serde_json::from_str::<serde_json::Value>(&observed).unwrap(),
+ json!([0, []]),
+ "{mutation}"
+ );
+ }
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn native_element_click_stops_after_document_replacement_in_pointer_handler() {
+ for event in ["mousemove", "mousedown"] {
+ let mut ctx = fixture().await;
+ assert!(evaluate_bool(&mut ctx, &format!(r#"(() => {{
+ document.getElementById('target').addEventListener('{event}', () => {{
+ document.open();document.write('<button id="replacement" style="position:absolute;left:40px;top:40px;width:120px;height:70px">new</button>');document.close();
+ window.successorEvents=[];
+ for(const type of ['mousemove','mousedown','mouseup','click'])
+ document.getElementById('replacement').addEventListener(type,()=>successorEvents.push(type));
+ }});
+ return true;
+ }})()"#)).await);
+ let click = prepare(&mut ctx).await;
+ assert!(matches!(
+ command(&mut ctx, DevToolsElementClickOperation::Dispatch(click)).await,
+ DevToolsCommandResult::ElementClickDispatch(Ok(()))
+ ));
+ assert_eq!(
+ evaluate_string(&mut ctx, "JSON.stringify(successorEvents)").await,
+ "[]",
+ "{event}"
+ );
+ }
+}
diff --git a/moli-protocol/src/domains/input/tests/keyboard_events.rs b/moli-protocol/src/domains/input/tests/keyboard_events.rs
index d34c4b89c..55eccf384 100644
--- a/moli-protocol/src/domains/input/tests/keyboard_events.rs
+++ b/moli-protocol/src/domains/input/tests/keyboard_events.rs
@@ -410,3 +410,103 @@ async fn cdp_insert_text_does_not_manufacture_keyboard_events() {
);
}
}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn cdp_deletion_observes_live_selection_after_beforeinput_without_temporary_selection() {
+ // Chromium 145: beforeinput sees the original caret. An uncanceled edit
+ // uses listener changes; cancellation preserves them without a rollback.
+ for control in &CONTROLS[..2] {
+ for (effect, canceled_value, canceled_selection, backward, forward, editable) in [
+ ("", "abc", [1, 1], ("bc", [0, 0]), ("ac", [1, 1]), true),
+ (
+ "field.setSelectionRange(2,2)",
+ "abc",
+ [2, 2],
+ ("ac", [1, 1]),
+ ("ab", [2, 2]),
+ true,
+ ),
+ (
+ "field.setSelectionRange(0,2)",
+ "abc",
+ [0, 2],
+ ("c", [0, 0]),
+ ("c", [0, 0]),
+ true,
+ ),
+ (
+ "field.value='wxyz';field.setSelectionRange(2,2)",
+ "wxyz",
+ [2, 2],
+ ("wyz", [1, 1]),
+ ("wxz", [2, 2]),
+ true,
+ ),
+ (
+ "field.readOnly=true",
+ "abc",
+ [1, 1],
+ ("abc", [1, 1]),
+ ("abc", [1, 1]),
+ false,
+ ),
+ (
+ "field.remove()",
+ "abc",
+ [1, 1],
+ ("abc", [1, 1]),
+ ("abc", [1, 1]),
+ false,
+ ),
+ ] {
+ for (key, uncanceled) in [("Backspace", backward), ("Delete", forward)] {
+ for cancel in [false, true] {
+ let mut ctx = keyboard_fixture(control).await;
+ assert!(evaluate_bool(&mut ctx, &format!(r#"(() => {{
+ const field = document.getElementById('field');
+ window.__field = field; window.__selectionEvents = [];
+ field.value='abc'; field.setSelectionRange(1,1);
+ for (const type of ['beforeinput', 'input']) field.addEventListener(type, e => {{
+ __selectionEvents.push([type,field.selectionStart,field.selectionEnd]);
+ if(type === 'beforeinput') {{ {effect}; if({cancel}) e.preventDefault(); }}
+ }});
+ return true;
+ }})()"#)).await);
+ dispatch(&mut ctx, "rawKeyDown", key, key, "").await;
+ let (value, selection) = if cancel {
+ (canceled_value, canceled_selection)
+ } else {
+ uncanceled
+ };
+ let mut expected_events = vec![json!(["beforeinput", 1, 1])];
+ if !cancel && editable {
+ expected_events.push(json!(["input", selection[0], selection[1]]));
+ }
+ let actual: serde_json::Value = serde_json::from_str(&evaluate_string(&mut ctx,
+ "JSON.stringify([__field.value,[__field.selectionStart,__field.selectionEnd],__selectionEvents])").await).unwrap();
+ assert_eq!(
+ actual,
+ json!([value, selection, expected_events]),
+ "{control} {key} {effect} cancel={cancel}"
+ );
+ }
+ }
+ }
+ }
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn cdp_deletion_at_text_boundary_still_dispatches_beforeinput_without_editing() {
+ for control in &CONTROLS[..2] {
+ for (key, caret) in [("Backspace", 0), ("Delete", 3)] {
+ let mut ctx = keyboard_fixture(control).await;
+ assert!(evaluate_bool(&mut ctx, &format!("(()=>{{const field=document.getElementById('field');field.value='abc';field.setSelectionRange({caret},{caret});return true}})()")).await);
+ dispatch(&mut ctx, "rawKeyDown", key, key, "").await;
+ assert_eq!(
+ events(&mut ctx).await,
+ json!(["keydown:field", "beforeinput:field"])
+ );
+ assert_eq!(field_value(&mut ctx).await, "abc");
+ }
+ }
+}
diff --git a/moli-renderer-v8/src/devtools/command.rs b/moli-renderer-v8/src/devtools/command.rs
index 74e78cf6c..9962e30ef 100644
--- a/moli-renderer-v8/src/devtools/command.rs
+++ b/moli-renderer-v8/src/devtools/command.rs
@@ -607,6 +607,7 @@ impl RendererInspectorCommandEnvelope {
RendererInspectorPageCommand::OuterHtmlForObjectId { .. } => {
Some("OuterHtmlForObjectId")
}
+ RendererInspectorPageCommand::PrepareElementClick { .. } => Some("PrepareElementClick"),
RendererInspectorPageCommand::ScrollObjectNodeIntoViewIfNeeded { .. } => {
Some("ScrollObjectNodeIntoViewIfNeeded")
}
diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rs
index 936a4936b..f52835290 100644
--- a/moli-renderer-v8/src/lib.rs
+++ b/moli-renderer-v8/src/lib.rs
@@ -315,6 +315,9 @@ pub use runtime::{
RendererTouchPoint, RendererVisualStateToken, RendererWindowDocumentSource,
RuntimeConsoleMessageSnapshot, renderer_output_transport_channel,
};
+pub use runtime::{
+ RendererElementClickError, RendererElementClickTarget, RendererPreparedPointerClick,
+};
pub use service_worker_runtime::{
SharedServiceWorkerResourceStore, new_shared_json_service_worker_resource_store,
new_shared_service_worker_resource_store,
diff --git a/moli-renderer-v8/src/native_bridge/element.rs b/moli-renderer-v8/src/native_bridge/element.rs
index fc865fc9f..2bb095667 100644
--- a/moli-renderer-v8/src/native_bridge/element.rs
+++ b/moli-renderer-v8/src/native_bridge/element.rs
@@ -207,7 +207,8 @@ pub(crate) use events::{
construct_pointer_event_with_related_target,
construct_pointer_event_with_related_target_and_modifiers, construct_simple_event,
construct_submit_event, construct_toggle_event, construct_touch_event,
- construct_touch_event_with_points, construct_wheel_event, dispatch_public_event,
+ construct_touch_event_with_points, construct_wheel_event, dispatch_beforeinput,
+ dispatch_public_event,
};
use events::{construct_click_event, construct_click_event_with_detail_and_modifiers};
pub(crate) use focus::{
@@ -333,7 +334,7 @@ pub(crate) use forms::{
cache_input_files_from_selected_files, form_control_is_effectively_disabled,
};
pub(crate) use forms::{
- dispatch_text_control_event, is_text_control,
+ dispatch_text_control_event, is_text_control, perform_implicit_submission_from_control,
queue_text_control_document_selection_change_event, replace_text_control_selection,
text_control_set_selection_range_internal,
text_control_set_selection_range_with_direction_internal, text_control_value,
@@ -397,7 +398,7 @@ pub(crate) use geometry::{
observable_input_surface_hit_test, observable_scroll_adjusted_client_rect,
observable_sources_with_fragments, perform_scrollbar_scroll_default_action,
perform_wheel_scroll_default_action, queue_scroll_observable_effects,
- scroll_node_into_view_at_start,
+ scroll_node_into_view_at_center, scroll_node_into_view_at_start,
};
pub(super) use geometry::{
node_client_height_getter_function, node_client_left_getter_function,
@@ -7560,3 +7561,5 @@ pub(in crate::native_bridge::element) fn resolved_reflected_element_attribute_ha
reflected_element_attribute_handle(runtime, owner, attribute)
.and_then(|candidate| runtime.dom_host().resolve_reference_target_chain(candidate))
}
+
+pub(crate) use geometry::observable_client_rects;
diff --git a/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs b/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs
index 8818d2181..8b8293a6a 100644
--- a/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs
+++ b/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs
@@ -26,7 +26,7 @@ use super::super::{
NodePublicEventDispatchOutcome, TextEditInputType, cache_input_files_from_selected_files,
construct_click_event_with_detail_and_modifiers, construct_command_event,
construct_input_event, construct_simple_event, contenteditable_editing_host,
- dispatch_popover_toggle_events, dispatch_public_event, element_attribute,
+ dispatch_beforeinput, dispatch_popover_toggle_events, dispatch_public_event, element_attribute,
element_has_attribute, form_associated_form_owner, is_disabled_form_control, is_focusable,
is_valid_submit_button, label_activation_control_handle, observable_bounding_client_rect,
perform_popover_invoker_default_action, perform_summary_click_default_action,
@@ -547,15 +547,13 @@ pub(crate) fn replace_contenteditable_selection(
let Some(target) = node_wrapper_from_handle(scope, handle) else {
return false;
};
- let Some(before_input) = construct_input_event(
+ if !dispatch_beforeinput(
scope,
- "beforeinput",
+ runtime_ptr,
+ handle,
input_type,
input_type.data(replacement_text),
- ) else {
- return false;
- };
- if !dispatch_public_event(scope, runtime_ptr, handle, before_input).allows_default() {
+ ) {
return false;
}
let inserted = if let Some(selection) = window_selection(scope) {
@@ -764,6 +762,12 @@ fn dispatch_click_event(
Some(dispatch_public_event(scope, runtime_ptr, handle, event))
}
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum ClickFocusBehavior {
+ Apply,
+ Preserve,
+}
+
#[allow(clippy::too_many_arguments)]
fn click_handle_internal(
scope: &mut v8::PinScope<'_, '_>,
@@ -776,7 +780,7 @@ fn click_handle_internal(
click_detail: i32,
modifiers: u8,
user_initiated: bool,
- focus_before_dispatch: bool,
+ focus_behavior: ClickFocusBehavior,
) -> RendererInputDispatchOutcome {
let runtime = unsafe { &*runtime_ptr };
if is_disabled_form_control(runtime, handle) {
@@ -787,7 +791,8 @@ fn click_handle_internal(
pending_file_chooser: None,
};
}
- if focus_before_dispatch && (user_initiated || synthetic_click_focuses_element(runtime, handle))
+ if focus_behavior == ClickFocusBehavior::Apply
+ && (user_initiated || synthetic_click_focuses_element(runtime, handle))
{
let focus_handle = if is_focusable(runtime, handle) {
Some(handle)
@@ -980,7 +985,7 @@ fn click_handle_internal(
user_initiated,
// Label activation focuses its associated control,
// even when the initiating script click does not.
- true,
+ ClickFocusBehavior::Apply,
);
pending_file_chooser = control_outcome.pending_file_chooser;
control_outcome.pending_download
@@ -1145,7 +1150,7 @@ pub(crate) fn activate_handle_via_click(
0,
0,
true,
- true,
+ ClickFocusBehavior::Apply,
)
}
@@ -1171,7 +1176,7 @@ pub(crate) fn activate_handle_via_click_with_detail_and_modifiers(
click_detail,
modifiers,
true,
- true,
+ ClickFocusBehavior::Apply,
)
}
@@ -1194,7 +1199,7 @@ pub(crate) fn activate_default_submit_button_via_keyboard(
0,
modifiers,
true,
- false,
+ ClickFocusBehavior::Preserve,
)
}
@@ -1223,7 +1228,7 @@ pub(crate) fn activate_handle_after_pointer_release(
click_detail,
modifiers,
true,
- false,
+ ClickFocusBehavior::Preserve,
)
}
@@ -1247,7 +1252,7 @@ pub(crate) fn activate_handle_via_synthetic_click(
0,
0,
false,
- false,
+ ClickFocusBehavior::Preserve,
)
}
@@ -1474,7 +1479,7 @@ fn perform_click_default_action(
0,
modifiers,
user_initiated,
- true,
+ ClickFocusBehavior::Apply,
);
return None;
}
diff --git a/moli-renderer-v8/src/native_bridge/element/events.rs b/moli-renderer-v8/src/native_bridge/element/events.rs
index 823d5cd91..fc2719d9c 100644
--- a/moli-renderer-v8/src/native_bridge/element/events.rs
+++ b/moli-renderer-v8/src/native_bridge/element/events.rs
@@ -17,7 +17,9 @@ pub(crate) use self::constructors::{
pub(super) use self::constructors::{
construct_click_event, construct_click_event_with_detail_and_modifiers,
};
-pub(crate) use self::dispatch::{NodePublicEventDispatchOutcome, dispatch_public_event};
+pub(crate) use self::dispatch::{
+ NodePublicEventDispatchOutcome, dispatch_beforeinput, dispatch_public_event,
+};
fn event_constructor<'s>(
scope: &mut v8::PinScope<'s, '_>,
diff --git a/moli-renderer-v8/src/native_bridge/element/events/dispatch.rs b/moli-renderer-v8/src/native_bridge/element/events/dispatch.rs
index 0611e0c06..c656eafdd 100644
--- a/moli-renderer-v8/src/native_bridge/element/events/dispatch.rs
+++ b/moli-renderer-v8/src/native_bridge/element/events/dispatch.rs
@@ -5,6 +5,23 @@ use crate::{
};
use super::super::JsContextHost;
+use super::{TextEditInputType, construct_input_event};
+
+/// The cancelable boundary before an editing default action. Callers must not
+/// mutate the value or selection until this returns true, and must re-read
+/// state that listeners may have changed.
+pub(crate) fn dispatch_beforeinput(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ target: DomHandle,
+ input_type: TextEditInputType,
+ data: Option<&str>,
+) -> bool {
+ let Some(event) = construct_input_event(scope, "beforeinput", input_type, data) else {
+ return false;
+ };
+ dispatch_public_event(scope, runtime_ptr, target, event).allows_default()
+}
#[derive(Clone, Copy, Debug, Default)]
pub(crate) struct NodePublicEventDispatchOutcome {
diff --git a/moli-renderer-v8/src/native_bridge/element/forms.rs b/moli-renderer-v8/src/native_bridge/element/forms.rs
index 3b195f494..ab44955dc 100644
--- a/moli-renderer-v8/src/native_bridge/element/forms.rs
+++ b/moli-renderer-v8/src/native_bridge/element/forms.rs
@@ -224,7 +224,6 @@ pub(in crate::native_bridge) use self::simple_controls::{
progress_max_setter_function, progress_position_getter_function,
progress_value_getter_function, progress_value_setter_function,
};
-pub(crate) use self::submission::submit_form_with_submit_event;
pub(in crate::native_bridge) use self::submission::{
FormAssociatedResetCallbackTiming, form_request_submit_callback, form_reset_callback,
form_submit_callback, reset_form_default_action,
@@ -233,6 +232,9 @@ pub(crate) use self::submission::{
align_event_constructor_function_realm_with_constructor,
align_event_constructor_function_realm_with_target,
};
+pub(crate) use self::submission::{
+ perform_implicit_submission_from_control, submit_form_with_submit_event,
+};
pub(crate) use self::text_control::{
dispatch_text_control_event, is_text_control,
queue_text_control_document_selection_change_event, replace_text_control_selection,
diff --git a/moli-renderer-v8/src/native_bridge/element/forms/submission.rs b/moli-renderer-v8/src/native_bridge/element/forms/submission.rs
index e2069fa45..b9d609bb0 100644
--- a/moli-renderer-v8/src/native_bridge/element/forms/submission.rs
+++ b/moli-renderer-v8/src/native_bridge/element/forms/submission.rs
@@ -1,10 +1,14 @@
use super::*;
use crate::blob;
use crate::native_bridge::context_host::ChildBrowsingContextNavigationRequest;
-use crate::native_bridge::element::NodePublicEventDispatchOutcome;
use crate::native_bridge::element::activation::{
SpecialBrowsingContextTarget, named_iframe_target_handle_for_navigation,
};
+use crate::native_bridge::element::{
+ NodePublicEventDispatchOutcome, TextEditInputType, activate_default_submit_button_via_keyboard,
+ dispatch_beforeinput,
+};
+use crate::runtime::RendererInputDispatchOutcome;
use crate::util::{v8_string, v8str};
use moli_dom::forms::normalize_form_submission_newlines;
use moli_encoding::{
@@ -13,6 +17,119 @@ use moli_encoding::{
};
use url::Url;
+/// Runs the control's Enter default action, including its beforeinput gate.
+/// None means this target is not eligible; cancellation is a handled branch
+/// and must never fall through to ordinary character insertion.
+pub(crate) fn perform_implicit_submission_from_control(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ control: DomHandle,
+ modifiers: u8,
+) -> Option<RendererInputDispatchOutcome> {
+ if !input_blocks_implicit_submission(unsafe { &*runtime_ptr }, control) {
+ return None;
+ }
+ if !dispatch_beforeinput(
+ scope,
+ runtime_ptr,
+ control,
+ TextEditInputType::InsertLineBreak,
+ None,
+ ) {
+ return Some(RendererInputDispatchOutcome::default());
+ }
+ // beforeinput can change the control type, form owner, or document.
+ let runtime = unsafe { &*runtime_ptr };
+ if !runtime.dom_host().is_connected(control)
+ || !input_blocks_implicit_submission(runtime, control)
+ {
+ return Some(RendererInputDispatchOutcome::default());
+ }
+ Some(perform_implicit_form_submission(
+ scope,
+ runtime_ptr,
+ control,
+ modifiers,
+ ))
+}
+
+fn input_blocks_implicit_submission(runtime: &JsContextHost, handle: DomHandle) -> bool {
+ runtime
+ .dom_host()
+ .node(handle)
+ .and_then(Node::as_element)
+ .is_some_and(|element| {
+ element.is_html_input()
+ && matches!(
+ element.input_type(),
+ InputType::Text
+ | InputType::Search
+ | InputType::Tel
+ | InputType::Url
+ | InputType::Email
+ | InputType::Password
+ | InputType::Date
+ | InputType::Month
+ | InputType::Week
+ | InputType::Time
+ | InputType::DatetimeLocal
+ | InputType::Number
+ )
+ })
+}
+
+fn perform_implicit_form_submission(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ handle: DomHandle,
+ modifiers: u8,
+) -> RendererInputDispatchOutcome {
+ let runtime = unsafe { &*runtime_ptr };
+ let Some(form_handle) = form_associated_form_owner(runtime, handle) else {
+ return RendererInputDispatchOutcome {
+ handled: true,
+ ..Default::default()
+ };
+ };
+ // The form.elements collection excludes image inputs, but an image input
+ // is still a submit button for the implicit-submission default-button
+ // search. Use the complete form-data control traversal here.
+ let controls = form_data_control_elements(runtime, form_handle);
+ if let Some(default_button) = controls
+ .iter()
+ .copied()
+ .find(|candidate| is_valid_submit_button(runtime, *candidate))
+ {
+ return activate_default_submit_button_via_keyboard(
+ scope,
+ runtime_ptr,
+ default_button,
+ modifiers,
+ );
+ }
+ if controls
+ .iter()
+ .filter(|candidate| input_blocks_implicit_submission(runtime, **candidate))
+ .count()
+ > 1
+ {
+ return RendererInputDispatchOutcome {
+ handled: true,
+ ..Default::default()
+ };
+ }
+
+ let had_pending_top_level_navigation = runtime.has_pending_location_navigation();
+ let _ = submit_form_with_submit_event(scope, runtime_ptr, form_handle, None, true);
+ RendererInputDispatchOutcome {
+ handled: true,
+ triggered_top_level_navigation: !had_pending_top_level_navigation
+ && unsafe { &*runtime_ptr }.has_pending_location_navigation(),
+ pending_download: None,
+ pending_file_chooser: None,
+ }
+}
+
const FORM_SUBMISSION_MULTIPART_BOUNDARY_PREFIX: &str = "----MoliFormBoundary";
enum FormResetPlan {
diff --git a/moli-renderer-v8/src/native_bridge/element/forms/text_control/selection.rs b/moli-renderer-v8/src/native_bridge/element/forms/text_control/selection.rs
index d6cbceafb..a4b56ea72 100644
--- a/moli-renderer-v8/src/native_bridge/element/forms/text_control/selection.rs
+++ b/moli-renderer-v8/src/native_bridge/element/forms/text_control/selection.rs
@@ -5,8 +5,13 @@ use super::value::{
};
use super::*;
use crate::dom::forms::parse_non_negative_length_attribute;
-use crate::native_bridge::element::{TextEditInputType, construct_input_event};
-use crate::util::{utf16_replace_units_range_lossy, utf16_units, v8str};
+use crate::native_bridge::element::{
+ TextEditInputType, construct_input_event, dispatch_beforeinput,
+};
+use crate::util::{
+ utf16_next_scalar_boundary, utf16_previous_scalar_boundary, utf16_replace_units_range_lossy,
+ utf16_scalar_boundary_at_or_after, utf16_units, v8str,
+};
use crate::webidl;
#[derive(webidl::WebIdlArgs)]
@@ -121,20 +126,26 @@ pub(crate) fn replace_text_control_selection(
return false;
}
- let Some(before_input) = construct_input_event(
+ if !dispatch_beforeinput(
scope,
- "beforeinput",
+ runtime_ptr,
+ handle,
input_type,
input_type.data(replacement_text),
- ) else {
- return false;
- };
- if !dispatch_public_event(scope, runtime_ptr, handle, before_input).allows_default() {
+ ) {
return false;
}
let runtime = unsafe { &*runtime_ptr };
- if !is_text_control(runtime, handle) {
+ if !is_text_control(runtime, handle)
+ || !runtime.dom_host().is_connected(handle)
+ || crate::native_bridge::element::form_control_is_effectively_disabled(runtime, handle)
+ || runtime
+ .dom_host()
+ .node(handle)
+ .and_then(Node::as_element)
+ .is_some_and(|element| element.attribute("readonly").is_some())
+ {
return false;
}
let value = text_control_value(runtime, handle);
@@ -156,8 +167,31 @@ pub(crate) fn replace_text_control_selection(
let value_len = value_units.len() as u32;
(value_len, value_len)
});
- let start = (start as usize).min(value_units.len());
- let end = (end as usize).min(value_units.len()).max(start);
+ let mut start = (start as usize).min(value_units.len());
+ let mut end = (end as usize).min(value_units.len()).max(start);
+ if matches!(
+ input_type,
+ TextEditInputType::DeleteContentBackward | TextEditInputType::DeleteContentForward
+ ) {
+ // Recompute against the live selection after beforeinput. In particular,
+ // never expose a temporary expanded deletion range to event listeners.
+ start = utf16_scalar_boundary_at_or_after(&value_units, start);
+ end = utf16_scalar_boundary_at_or_after(&value_units, end);
+ if start == end {
+ match input_type {
+ TextEditInputType::DeleteContentBackward => {
+ start = utf16_previous_scalar_boundary(&value_units, start)
+ }
+ TextEditInputType::DeleteContentForward => {
+ end = utf16_next_scalar_boundary(&value_units, end)
+ }
+ _ => unreachable!(),
+ }
+ }
+ if start == end {
+ return false;
+ }
+ }
let replacement_units = text_control_user_edit_replacement_units(
runtime,
handle,
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry.rs b/moli-renderer-v8/src/native_bridge/element/geometry.rs
index f4b825ba8..e402bb858 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry.rs
@@ -43,5 +43,6 @@ pub(crate) use scroll::{
perform_wheel_scroll_default_action, queue_scroll_observable_effects,
};
pub(crate) use scroll_into_view::{
- scroll_node_into_view_at_start, scroll_node_into_view_if_needed,
+ scroll_node_into_view_at_center, scroll_node_into_view_at_start,
+ scroll_node_into_view_if_needed,
};
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/scroll_into_view.rs b/moli-renderer-v8/src/native_bridge/element/geometry/scroll_into_view.rs
index bd048f918..54573c67e 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry/scroll_into_view.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/scroll_into_view.rs
@@ -146,6 +146,24 @@ fn scroll_node_into_view_with_params(
perform_bubbling_scroll_into_view(scope, runtime_ptr, target, geometry, params, 0).map(Some)
}
+pub(crate) fn scroll_node_into_view_at_center(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ handle: DomHandle,
+) -> Result<Option<bool>, moli_layout::LayoutError> {
+ scroll_node_into_view_with_params(
+ scope,
+ runtime_ptr,
+ handle,
+ None,
+ ScrollIntoViewParams {
+ horizontal: ScrollIntoViewAlignment::Center,
+ vertical: ScrollIntoViewAlignment::Center,
+ center_if_fully_hidden: false,
+ },
+ )
+}
+
pub(crate) fn scroll_node_into_view_at_start(
scope: &mut v8::PinScope<'_, '_>,
runtime_ptr: *mut JsContextHost,
diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rs
index 4d278c9c1..0880947fa 100644
--- a/moli-renderer-v8/src/runtime/mod.rs
+++ b/moli-renderer-v8/src/runtime/mod.rs
@@ -83,6 +83,9 @@ pub(crate) use self::script_preloads::{
};
pub use self::page_creation_progress::{RendererPageCreationPhase, RendererPageCreationProgress};
+pub use self::page_surface::{
+ RendererElementClickError, RendererElementClickTarget, RendererPreparedPointerClick,
+};
pub(crate) use self::browser_context_runtime::RendererOutputTransportSenderSlot;
pub(in crate::runtime) use self::document_lifecycle_turn::PendingDocumentLifecycleTurn;
diff --git a/moli-renderer-v8/src/runtime/owner.rs b/moli-renderer-v8/src/runtime/owner.rs
index 08d78a6a2..808a5bdd4 100644
--- a/moli-renderer-v8/src/runtime/owner.rs
+++ b/moli-renderer-v8/src/runtime/owner.rs
@@ -4866,16 +4866,13 @@ impl RendererOwnerHandle {
fn merge_pending_download_into_reply(
&self,
- reply: RendererPageReply,
+ mut reply: RendererPageReply,
download: RendererPendingDownloadActivation,
) -> RendererPageReply {
- match reply {
- RendererPageReply::InputDispatchOutcome(mut outcome) => {
- outcome.pending_download = Some(download);
- RendererPageReply::InputDispatchOutcome(outcome)
- }
- other => other,
+ if let Some(outcome) = reply.input_dispatch_outcome_mut() {
+ outcome.pending_download = Some(download);
}
+ reply
}
async fn finish_live_page_navigation_completion(
diff --git a/moli-renderer-v8/src/runtime/owner_local_store/mod.rs b/moli-renderer-v8/src/runtime/owner_local_store/mod.rs
index 3b355260b..b699d9278 100644
--- a/moli-renderer-v8/src/runtime/owner_local_store/mod.rs
+++ b/moli-renderer-v8/src/runtime/owner_local_store/mod.rs
@@ -2600,16 +2600,16 @@ impl RendererOwnerLocalStore {
// mousemove, focus, etc.). Publish that real pending navigation at this
// input task's completion, not as a side effect of a later Runtime
// command. Preserve the action-specific download/file-chooser result.
- if let Ok(RendererPageReply::InputDispatchOutcome(outcome)) = &mut reply {
+ if let Ok(reply) = &mut reply
+ && let Some(outcome) = reply.input_dispatch_outcome_mut()
+ {
outcome.triggered_top_level_navigation |=
entry.page_vm().vm().has_pending_location_navigation();
}
let input_triggered_top_level_navigation = reply.as_ref().is_ok_and(|reply| {
- matches!(
- reply,
- RendererPageReply::InputDispatchOutcome(outcome)
- if outcome.triggered_top_level_navigation
- )
+ reply
+ .input_dispatch_outcome()
+ .is_some_and(|outcome| outcome.triggered_top_level_navigation)
});
let should_delegate_location_navigation = replacement_lifecycle.is_ok()
&& runtime_command_completion.is_ok()
diff --git a/moli-renderer-v8/src/runtime/page_commands.rs b/moli-renderer-v8/src/runtime/page_commands.rs
index de7390626..255205b4c 100644
--- a/moli-renderer-v8/src/runtime/page_commands.rs
+++ b/moli-renderer-v8/src/runtime/page_commands.rs
@@ -74,6 +74,13 @@ impl PageVm {
.vm_mut()
.navigate_top_level_same_document_from_browser(&url)
.map(RendererPageReply::Bool),
+ RendererPageCommand::DispatchPreparedElementClick(click) => {
+ let mut outcome = self.vm_mut().dispatch_prepared_element_click(click);
+ if let Ok(outcome) = &mut outcome {
+ self.bind_input_dispatch_file_chooser_backend_node_id(outcome);
+ }
+ Ok(RendererPageReply::ElementClickDispatch(outcome))
+ }
RendererPageCommand::DispatchMouseEventAtPoint {
x,
y,
@@ -1260,6 +1267,14 @@ impl PageVm {
)?,
))
}
+ RendererInspectorPageCommand::PrepareElementClick { object_id } => {
+ let handle = self.vm_mut().live_node_handle_for_runtime_object_id(inspector_session_id, &object_id)?;
+ let preparation = match handle {
+ Some(handle) => self.vm_mut().prepare_element_click(handle),
+ None => Err(RendererElementClickError::StaleNode),
+ };
+ Ok(RendererPageReply::ElementClickPreparation(preparation))
+ }
RendererInspectorPageCommand::ScrollObjectNodeIntoViewIfNeeded { object_id, rect } => {
self.scroll_node_into_view_if_needed_for_object_id(
inspector_session_id,
diff --git a/moli-renderer-v8/src/runtime/page_dom.rs b/moli-renderer-v8/src/runtime/page_dom.rs
index d4c4842a2..6afb87aa2 100644
--- a/moli-renderer-v8/src/runtime/page_dom.rs
+++ b/moli-renderer-v8/src/runtime/page_dom.rs
@@ -642,7 +642,7 @@ impl PageVm {
Ok(outcome)
}
- fn bind_input_dispatch_file_chooser_backend_node_id(
+ pub(super) fn bind_input_dispatch_file_chooser_backend_node_id(
&mut self,
outcome: &mut RendererInputDispatchOutcome,
) {
diff --git a/moli-renderer-v8/src/runtime/page_surface.rs b/moli-renderer-v8/src/runtime/page_surface.rs
index 66c4f5848..9c6e10d05 100644
--- a/moli-renderer-v8/src/runtime/page_surface.rs
+++ b/moli-renderer-v8/src/runtime/page_surface.rs
@@ -26,6 +26,11 @@ use std::{
};
use tokio::sync::oneshot;
+mod element_click;
+pub use element_click::{
+ RendererElementClickError, RendererElementClickTarget, RendererPreparedPointerClick,
+};
+
mod javascript_dialog;
mod popup_activation;
mod window_document_source;
@@ -419,7 +424,7 @@ pub struct RendererDragData {
pub drag_operations_mask: i32,
}
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct RendererInputDispatchOutcome {
pub handled: bool,
pub triggered_top_level_navigation: bool,
@@ -4761,6 +4766,9 @@ pub(crate) enum RendererInspectorPageCommand {
ComputedStylePropertiesForObjectId {
object_id: String,
},
+ PrepareElementClick {
+ object_id: String,
+ },
ScrollObjectNodeIntoViewIfNeeded {
object_id: String,
rect: Option<moli_page_types::DomScrollIntoViewRect>,
@@ -4869,6 +4877,7 @@ pub enum RendererPageCommand {
RefreshFullPageState,
PageDiagnosticsSnapshot,
HasPendingLocationNavigation,
+ DispatchPreparedElementClick(RendererPreparedPointerClick),
DispatchMouseEventAtPoint {
x: f64,
y: f64,
@@ -5491,6 +5500,13 @@ impl RendererPageCommand {
)
}
+ pub fn prepare_element_click(inspector_session_id: Option<String>, object_id: String) -> Self {
+ Self::inspector_command(
+ inspector_session_id,
+ RendererInspectorPageCommand::PrepareElementClick { object_id },
+ )
+ }
+
pub fn scroll_object_node_into_view_if_needed(
inspector_session_id: Option<String>,
object_id: String,
@@ -6101,6 +6117,8 @@ pub enum RendererCaptureScreencastFrameReply {
}
pub enum RendererPageReply {
+ ElementClickPreparation(Result<RendererElementClickTarget, RendererElementClickError>),
+ ElementClickDispatch(Result<RendererInputDispatchOutcome, RendererElementClickError>),
RuntimeEvaluationResult(RendererRuntimeEvaluationResult),
RuntimeInspectorProtocolMessages(RendererRuntimeCommandOutput),
RuntimeConsoleMessageSnapshots(Vec<RuntimeConsoleMessageSnapshot>),
@@ -6336,3 +6354,25 @@ impl RendererPageTable {
.and_then(|entry| entry.in_flight_command_epoch)
}
}
+
+impl RendererPageReply {
+ pub(crate) fn input_dispatch_outcome(&self) -> Option<&RendererInputDispatchOutcome> {
+ match self {
+ Self::InputDispatchOutcome(outcome) | Self::ElementClickDispatch(Ok(outcome)) => {
+ Some(outcome)
+ }
+ _ => None,
+ }
+ }
+
+ pub(crate) fn input_dispatch_outcome_mut(
+ &mut self,
+ ) -> Option<&mut RendererInputDispatchOutcome> {
+ match self {
+ Self::InputDispatchOutcome(outcome) | Self::ElementClickDispatch(Ok(outcome)) => {
+ Some(outcome)
+ }
+ _ => None,
+ }
+ }
+}
diff --git a/moli-renderer-v8/src/runtime/page_surface/element_click.rs b/moli-renderer-v8/src/runtime/page_surface/element_click.rs
new file mode 100644
index 000000000..636bb0cfd
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_surface/element_click.rs
@@ -0,0 +1,31 @@
+use crate::document_runtime::DomHandle;
+use crate::frame_owner_model::DocumentId;
+use crate::runtime::RendererDocumentLifecycleIdentity;
+
+/// A preparation is bound to live renderer identities, never to a protocol
+/// frame id or a JavaScript status string.
+#[derive(Debug, Clone, PartialEq)]
+pub enum RendererElementClickTarget {
+ DomActivation,
+ Option,
+ FileInput,
+ Pointer(RendererPreparedPointerClick),
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct RendererPreparedPointerClick {
+ pub root_x: f64,
+ pub root_y: f64,
+ pub(crate) target: DomHandle,
+ pub(crate) root_document: Option<RendererDocumentLifecycleIdentity>,
+ pub(crate) documents: Vec<(DomHandle, DocumentId)>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum RendererElementClickError {
+ StaleNode,
+ MissingBrowsingContext,
+ NoClickableRect,
+ Obscured,
+ LayoutUnavailable(String),
+}
diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs
index 7cf719d9c..4bcb0b0ee 100644
--- a/moli-renderer-v8/src/script_vm.rs
+++ b/moli-renderer-v8/src/script_vm.rs
@@ -704,6 +704,7 @@ mod dom_debugger;
mod dom_inspector;
pub(crate) use dom_inspector::{DomInspectorEdit, DomInspectorEditOutcome};
mod drop_cleanup;
+mod element_click;
mod element_toggle_event;
mod eval_exec;
mod file_entry_file_callback;
diff --git a/moli-renderer-v8/src/script_vm/element_click.rs b/moli-renderer-v8/src/script_vm/element_click.rs
new file mode 100644
index 000000000..ba64c9ad7
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/element_click.rs
@@ -0,0 +1,210 @@
+use super::ScriptVm;
+use super::input_helpers::clear_input_dispatch_state;
+use crate::document_runtime::DomHandle;
+use crate::dom::{forms::InputType, native::Node};
+use crate::native_bridge::element::{observable_client_rects, scroll_node_into_view_at_center};
+use crate::runtime::{
+ RendererElementClickError as ClickError, RendererElementClickTarget as ClickTarget,
+ RendererInputDispatchOutcome, RendererPointerEventProperties, RendererPreparedPointerClick,
+};
+use moli_layout::{LayoutFlushReason, LayoutPoint, LayoutQuad};
+
+fn layout_error(error: impl std::fmt::Display) -> ClickError {
+ ClickError::LayoutUnavailable(error.to_string())
+}
+
+impl ScriptVm {
+ pub(crate) fn prepare_element_click(
+ &mut self,
+ handle: DomHandle,
+ ) -> Result<ClickTarget, ClickError> {
+ {
+ let host = self._context_host.borrow();
+ let element = host
+ .dom_host()
+ .node(handle)
+ .and_then(Node::as_element)
+ .filter(|_| host.dom_host().is_connected(handle))
+ .ok_or(ClickError::StaleNode)?;
+ if element.is_html_input() && element.input_type() == InputType::File {
+ return Ok(ClickTarget::FileInput);
+ }
+ if element.local_name() == "option" {
+ return Ok(ClickTarget::Option);
+ }
+ if !host.layout_policy().uses_real_layout() {
+ return Ok(ClickTarget::DomActivation);
+ }
+ }
+ self.with_default_context_scope(|scope, runtime_ptr| {
+ Ok(scroll_node_into_view_at_center(scope, runtime_ptr, handle)?)
+ })
+ .map_err(layout_error)?
+ .ok_or(ClickError::NoClickableRect)?;
+ self.prepare_pointer_click_geometry(handle)
+ .map(ClickTarget::Pointer)
+ }
+
+ fn prepare_pointer_click_geometry(
+ &mut self,
+ handle: DomHandle,
+ ) -> Result<RendererPreparedPointerClick, ClickError> {
+ self.reconcile_document_web_fonts_for_layout();
+ let (document, point, root_document) = {
+ let host = self._context_host.borrow();
+ if !host.dom_host().is_connected(handle) {
+ return Err(ClickError::StaleNode);
+ }
+ let document = host
+ .dom_host()
+ .owner_document_handle(handle)
+ .ok_or(ClickError::StaleNode)?;
+ let rect =
+ observable_client_rects(&host, handle, LayoutFlushReason::SynchronousGeometry)
+ .map_err(layout_error)?
+ .into_iter()
+ .next()
+ .ok_or(ClickError::NoClickableRect)?;
+ let viewport = host.layout_viewport_for_document(document);
+ let left = rect.left.max(0.0);
+ let top = rect.top.max(0.0);
+ let right = rect.right.min(f64::from(viewport.css_width));
+ let bottom = rect.bottom.min(f64::from(viewport.css_height));
+ if right <= left || bottom <= top {
+ return Err(ClickError::NoClickableRect);
+ }
+ (
+ document,
+ LayoutPoint::new(
+ ((left + right) / 2.0).floor() as f32,
+ ((top + bottom) / 2.0).floor() as f32,
+ ),
+ host.root_document_lifecycle_identity(),
+ )
+ };
+ // Use the same frame geometry composition as DOM geometry. The server
+ // must never reconstruct this transform from serialized box quads.
+ let mut quad = [LayoutQuad { points: [point; 4] }];
+ self.compose_layout_quads_to_top(document, &mut quad)
+ .map_err(layout_error)?;
+ let point = quad[0].points[0];
+ let hit = self
+ .observable_deep_hit_test_for_current_document(point, false)
+ .map_err(layout_error)?
+ .ok_or(ClickError::Obscured)?;
+ let mut documents = Vec::new();
+ let mut document_cursor = self
+ ._context_host
+ .borrow()
+ .dom_host()
+ .owner_document_handle(hit)
+ .ok_or(ClickError::MissingBrowsingContext)?;
+ loop {
+ let id = self
+ .document_id_for_live_node_handle(document_cursor)
+ .ok_or(ClickError::MissingBrowsingContext)?;
+ documents.push((document_cursor, id));
+ let host = self._context_host.borrow();
+ if document_cursor == host.document_handle() {
+ break;
+ }
+ let frame = host
+ .child_browsing_context_host_for_document_handle(document_cursor)
+ .ok_or(ClickError::MissingBrowsingContext)?;
+ document_cursor = host
+ .dom_host()
+ .owner_document_handle(frame)
+ .ok_or(ClickError::MissingBrowsingContext)?;
+ }
+ // The deep hit already passed every ancestor's clipping and paint
+ // order. Walk the live composed ancestry, including frame owners, to
+ // accept descendants without accidentally accepting sibling overlays.
+ let host = self._context_host.borrow();
+ let mut cursor = Some(hit);
+ while let Some(candidate) = cursor {
+ if candidate == handle {
+ return Ok(RendererPreparedPointerClick {
+ target: handle,
+ root_x: f64::from(point.x),
+ root_y: f64::from(point.y),
+ root_document,
+ documents,
+ });
+ }
+ cursor = host
+ .dom_host()
+ .parent_node(candidate)
+ .or_else(|| host.dom_host().shadow_root_host(candidate))
+ .or_else(|| host.child_browsing_context_host_for_document_handle(candidate));
+ }
+ Err(ClickError::Obscured)
+ }
+
+ fn click_documents_are_current(&self, click: &RendererPreparedPointerClick) -> bool {
+ self._context_host
+ .borrow()
+ .root_document_lifecycle_identity()
+ == click.root_document
+ && click
+ .documents
+ .iter()
+ .all(|(handle, id)| self.document_id_for_live_node_handle(*handle) == Some(*id))
+ }
+
+ pub(crate) fn dispatch_prepared_element_click(
+ &mut self,
+ click: RendererPreparedPointerClick,
+ ) -> Result<RendererInputDispatchOutcome, ClickError> {
+ if !self.click_documents_are_current(&click) {
+ return Err(ClickError::StaleNode);
+ }
+ if !self
+ ._context_host
+ .borrow()
+ .dom_host()
+ .is_connected(click.target)
+ {
+ return Err(ClickError::StaleNode);
+ }
+ // Preserve the point sampled during preparation. Each pointer phase
+ // uses the existing hit-test/snapshot policy; DOM or style mutations
+ // must not introduce an extra layout refresh or replay the sequence.
+ let mut outcome = RendererInputDispatchOutcome::default();
+ for (event, buttons) in [("mousemove", 0), ("mousedown", 1), ("mouseup", 0)] {
+ if !self.click_documents_are_current(&click) {
+ clear_input_dispatch_state(self);
+ break;
+ }
+ let dispatched = self.dispatch_mouse_event_at_point_with_pointer_and_modifiers(
+ click.root_x,
+ click.root_y,
+ event,
+ 0,
+ Some(buttons),
+ i32::from(event != "mousemove"),
+ 0.0,
+ 0.0,
+ RendererPointerEventProperties::default(),
+ 0,
+ );
+ let next = match dispatched {
+ Ok(next) => next,
+ Err(error) => {
+ clear_input_dispatch_state(self);
+ return Err(layout_error(error));
+ }
+ };
+ outcome.handled |= next.handled;
+ outcome.triggered_top_level_navigation |=
+ next.triggered_top_level_navigation || self.has_pending_location_navigation();
+ outcome.pending_download = next.pending_download.or(outcome.pending_download);
+ outcome.pending_file_chooser =
+ next.pending_file_chooser.or(outcome.pending_file_chooser);
+ if outcome.triggered_top_level_navigation {
+ clear_input_dispatch_state(self);
+ break;
+ }
+ }
+ Ok(outcome)
+ }
+}
diff --git a/moli-renderer-v8/src/script_vm/input_dispatch.rs b/moli-renderer-v8/src/script_vm/input_dispatch.rs
index 43fed60b7..17ad5addb 100644
--- a/moli-renderer-v8/src/script_vm/input_dispatch.rs
+++ b/moli-renderer-v8/src/script_vm/input_dispatch.rs
@@ -7,8 +7,7 @@ use super::input_helpers::{
MouseReleaseFollowUp, PendingMousePress, mouse_button_mask, single_changed_mouse_button,
};
use super::inspector::{
- current_selection_range, current_selection_state, is_space_key, key_target_info,
- option_is_disabled, radio_group_members,
+ current_selection_state, is_space_key, key_target_info, option_is_disabled, radio_group_members,
};
use super::{ActiveDragSession, ActiveScrollbarDrag, ActiveTouchPoint, ScriptVm};
use crate::document_runtime::DomHandle;
@@ -17,23 +16,21 @@ use crate::dom::{
native::{Node, SelectedFile},
};
use crate::native_bridge::element::{
- TextEditInputType, TouchEventPoint, activate_default_submit_button_via_keyboard,
- activate_handle_after_pointer_release, activate_handle_via_click,
- activate_handle_via_click_with_detail_and_modifiers, cache_input_files_from_selected_files,
- construct_drag_event, construct_input_event, construct_keyboard_event,
+ TextEditInputType, TouchEventPoint, activate_handle_after_pointer_release,
+ activate_handle_via_click, activate_handle_via_click_with_detail_and_modifiers,
+ cache_input_files_from_selected_files, construct_drag_event, construct_keyboard_event,
construct_mouse_event_with_detail_and_modifiers, construct_mouse_event_with_modifiers,
construct_mouse_event_with_related_target_and_modifiers, construct_pointer_event,
construct_pointer_event_with_modifiers, construct_pointer_event_with_related_target,
construct_pointer_event_with_related_target_and_modifiers, construct_simple_event,
construct_touch_event, construct_touch_event_with_points, construct_wheel_event,
- contenteditable_editing_host, dispatch_public_event, form_associated_form_owner,
- form_data_control_elements, is_text_control, is_valid_submit_button, observable_input_hit_test,
- observable_input_surface_hit_test, perform_auxiliary_link_default_action,
- perform_drop_default_action, perform_mouse_focus_default_action,
+ contenteditable_editing_host, dispatch_public_event, is_text_control,
+ observable_input_hit_test, observable_input_surface_hit_test,
+ perform_auxiliary_link_default_action, perform_drop_default_action,
+ perform_implicit_submission_from_control, perform_mouse_focus_default_action,
perform_scrollbar_scroll_default_action, perform_wheel_scroll_default_action,
replace_contenteditable_selection, replace_text_control_selection,
- select_contenteditable_contents, submit_form_with_submit_event,
- text_control_set_selection_range_internal,
+ select_contenteditable_contents, text_control_set_selection_range_internal,
text_control_set_selection_range_with_direction_internal, text_control_value, update_focus,
};
use crate::native_bridge::{
@@ -85,80 +82,6 @@ fn can_suppress_compat_mouse_event(event_name: &str) -> bool {
const MOUSE_POINTER_ID: i32 = 1;
const TOUCH_POINTER_ID: i32 = 2;
-fn input_blocks_implicit_submission(
- runtime: &crate::native_bridge::JsContextHost,
- handle: DomHandle,
-) -> bool {
- runtime
- .dom_host()
- .node(handle)
- .and_then(Node::as_element)
- .is_some_and(|element| {
- element.is_html_input()
- && matches!(
- element.input_type(),
- InputType::Text
- | InputType::Search
- | InputType::Tel
- | InputType::Url
- | InputType::Email
- | InputType::Password
- | InputType::Date
- | InputType::Month
- | InputType::Week
- | InputType::Time
- | InputType::DatetimeLocal
- | InputType::Number
- )
- })
-}
-
-fn perform_implicit_form_submission(
- scope: &mut v8::PinScope<'_, '_>,
- runtime_ptr: *mut crate::native_bridge::JsContextHost,
- handle: DomHandle,
- modifiers: u8,
-) -> RendererInputDispatchOutcome {
- let runtime = unsafe { &*runtime_ptr };
- let Some(form_handle) = form_associated_form_owner(runtime, handle) else {
- return input_dispatch_outcome(true);
- };
- // The form.elements collection excludes image inputs, but an image input
- // is still a submit button for the implicit-submission default-button
- // search. Use the complete form-data control traversal here.
- let controls = form_data_control_elements(runtime, form_handle);
- if let Some(default_button) = controls
- .iter()
- .copied()
- .find(|candidate| is_valid_submit_button(runtime, *candidate))
- {
- return activate_default_submit_button_via_keyboard(
- scope,
- runtime_ptr,
- default_button,
- modifiers,
- );
- }
- if controls
- .iter()
- .filter(|candidate| input_blocks_implicit_submission(runtime, **candidate))
- .count()
- > 1
- {
- return input_dispatch_outcome(true);
- }
-
- let had_pending_top_level_navigation = runtime.has_pending_location_navigation();
- let _ = submit_form_with_submit_event(scope, runtime_ptr, form_handle, None, true);
- RendererInputDispatchOutcome {
- handled: true,
- triggered_top_level_navigation: !had_pending_top_level_navigation
- && unsafe { &*runtime_ptr }.has_pending_location_navigation(),
- pending_download: None,
- pending_file_chooser: None,
- }
-}
-
struct PreparedMouseInputDispatch {
button: i32,
buttons: i32,
@@ -1985,28 +1908,15 @@ impl ScriptVm {
TextEditInputType::InsertLineBreak,
)));
}
- if input_blocks_implicit_submission(runtime, handle) && is_character_phase {
- // Enter's editing default action must remain cancelable before
- // activating a default submit button (and firing its click).
- let Some(before_input) = construct_input_event(
- scope,
- "beforeinput",
- TextEditInputType::InsertLineBreak,
- None,
- ) else {
- return Ok(input_dispatch_outcome(false));
- };
- if !dispatch_public_event(scope, runtime_ptr, handle, before_input)
- .allows_default()
- {
- return Ok(input_dispatch_outcome(false));
- }
- return Ok(perform_implicit_form_submission(
+ if is_character_phase
+ && let Some(outcome) = perform_implicit_submission_from_control(
scope,
runtime_ptr,
handle,
modifiers,
- ));
+ )
+ {
+ return Ok(outcome);
}
if event_name == "keydown" && (target.is_button_like || target.is_anchor_like) {
return Ok(activate_handle_via_click_with_detail_and_modifiers(
@@ -2175,28 +2085,6 @@ impl ScriptVm {
}
if target.is_text_control && matches!(key_lower.as_str(), "backspace" | "delete") {
- let value_units = utf16_units(&text_control_value(runtime, handle));
- let (start, end) = current_selection_range(runtime, handle);
- let start = utf16_scalar_boundary_at_or_after(&value_units, start as usize) as u32;
- let end = utf16_scalar_boundary_at_or_after(&value_units, end as usize) as u32;
- let (from, to) = if start != end {
- (start, end)
- } else if key_lower == "backspace" {
- (
- utf16_previous_scalar_boundary(&value_units, start as usize) as u32,
- start,
- )
- } else {
- (
- start,
- utf16_next_scalar_boundary(&value_units, start as usize) as u32,
- )
- };
- if from == to {
- return Ok(input_dispatch_outcome(true));
- }
- let _ =
- text_control_set_selection_range_internal(scope, runtime_ptr, handle, from, to);
return Ok(input_dispatch_outcome(replace_text_control_selection(
scope,
runtime_ptr,
diff --git a/moli-renderer-v8/src/script_vm/inspector/input_state.rs b/moli-renderer-v8/src/script_vm/inspector/input_state.rs
index 9f16232bd..2cd6665af 100644
--- a/moli-renderer-v8/src/script_vm/inspector/input_state.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/input_state.rs
@@ -109,26 +109,6 @@ pub(in crate::script_vm) fn radio_group_members(
.collect()
}
-pub(in crate::script_vm) fn current_selection_range(
- runtime: &JsContextHost,
- handle: DomHandle,
-) -> (u32, u32) {
- runtime
- .dom_host()
- .node(handle)
- .and_then(Node::as_element)
- .map(|element| {
- let start = element.selection_start();
- let end = element.selection_end();
- if start <= end {
- (start, end)
- } else {
- (end, end)
- }
- })
- .unwrap_or((0, 0))
-}
-
pub(in crate::script_vm) fn current_selection_state(
runtime: &JsContextHost,
handle: DomHandle,
diff --git a/moli-renderer-v8/src/script_vm/inspector/mod.rs b/moli-renderer-v8/src/script_vm/inspector/mod.rs
index 330066246..1b7d9819e 100644
--- a/moli-renderer-v8/src/script_vm/inspector/mod.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/mod.rs
@@ -20,8 +20,7 @@ use self::context_registry::DocumentInspectorContextGroupId;
pub(in crate::script_vm) use self::context_registry::DocumentInspectorContextRegistrationId;
use self::document_backend::DocumentInspectorBackendState;
pub(super) use self::input_state::{
- current_selection_range, current_selection_state, is_space_key, key_target_info,
- option_is_disabled, radio_group_members,
+ current_selection_state, is_space_key, key_target_info, option_is_disabled, radio_group_members,
};
pub(in crate::script_vm) use self::outbound::InspectorOutbound;
pub(super) use self::outbound::ScriptVmInspectorCommandTurnOutputScope;
diff --git a/moli-renderer-v8/src/script_vm/tests/element_click.rs b/moli-renderer-v8/src/script_vm/tests/element_click.rs
new file mode 100644
index 000000000..ad0e60d3d
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/element_click.rs
@@ -0,0 +1,132 @@
+use super::*;
+use crate::runtime::{RendererElementClickTarget, RendererPointerEventProperties};
+
+#[test]
+fn native_element_click_cold_preparation_keeps_existing_layout_cost() {
+ let markup = r#"<!doctype html><html><body>
+ <button id='target' style='position:absolute;left:40px;top:40px;width:120px;height:70px'>go</button>
+ </body></html>"#;
+ let mut reference = new_parsed_test_vm("https://click-js-geometry.test/", markup);
+ let before = reference.layout_pass_observability_for_test().1;
+ // The previous preflight's public geometry operations define the budget.
+ reference
+ .eval(
+ r#"(() => {
+ const target=document.getElementById('target');
+ target.scrollIntoView({block:'center',inline:'center',behavior:'instant'});
+ const rect=target.getClientRects()[0];
+ return document.elementFromPoint((rect.left+rect.right)/2,(rect.top+rect.bottom)/2).id;
+ })()"#,
+ )
+ .expect("existing geometry preparation");
+ let existing_passes = reference.layout_pass_observability_for_test().1 - before;
+
+ let mut vm = new_parsed_test_vm("https://click-native-geometry.test/", markup);
+ let target = vm.document_runtime.get_element_by_id("target").unwrap();
+ let before = vm.layout_pass_observability_for_test().1;
+ assert!(matches!(
+ vm.prepare_element_click(target).unwrap(),
+ RendererElementClickTarget::Pointer(_)
+ ));
+ assert!(
+ vm.layout_pass_observability_for_test().1 - before <= existing_passes,
+ "native preparation must not increase the existing cold layout cost"
+ );
+}
+
+#[test]
+fn native_element_click_reuses_frozen_layout_after_dom_and_style_changes() {
+ for mutation in [
+ "target.style.left='300px'",
+ "const veil=document.createElement('div');veil.style.cssText='position:fixed;inset:0;z-index:999';document.body.appendChild(veil)",
+ "const style=document.createElement('style');document.head.appendChild(style);style.sheet.insertRule('button {pointer-events:none}')",
+ ] {
+ let mut reference = None;
+ for native_sequence in [false, true] {
+ let mut vm = new_parsed_test_vm(
+ "https://click-snapshot.test/",
+ r#"<!doctype html><html><head></head><body>
+ <button id='target' style='position:absolute;left:40px;top:40px;width:120px;height:70px'>go</button>
+ </body></html>"#,
+ );
+ vm.eval(
+ r#"window.clicks=0;window.events=[];
+ document.getElementById('target').onclick=()=>clicks++;
+ for(const type of ['mousemove','mousedown','mouseup','click'])
+ document.addEventListener(type,e=>events.push([type,e.target.id]));"#,
+ )
+ .expect("install click listener");
+ let target = vm.document_runtime.get_element_by_id("target").unwrap();
+ let before = vm.layout_pass_observability_for_test().1;
+ vm.eval("document.elementFromPoint(100,75)")
+ .expect("populate the existing hit-test snapshot");
+ assert_eq!(vm.layout_pass_observability_for_test().1, before + 1);
+ let RendererElementClickTarget::Pointer(first) =
+ vm.prepare_element_click(target).unwrap()
+ else {
+ panic!("real layout must prepare pointer input");
+ };
+ assert_eq!(vm.layout_pass_observability_for_test().1, before + 1);
+
+ vm.eval(&format!(
+ "(()=>{{const target=document.getElementById('target');{mutation}}})()"
+ ))
+ .expect("mutate live DOM/style without requesting a fresh snapshot");
+ let RendererElementClickTarget::Pointer(click) =
+ vm.prepare_element_click(target).unwrap()
+ else {
+ panic!("real layout must prepare pointer input");
+ };
+ assert_eq!((click.root_x, click.root_y), (first.root_x, first.root_y));
+ assert_eq!(
+ vm.layout_pass_observability_for_test().1,
+ before + 1,
+ "warm preparation must reuse the frozen tree: {mutation}"
+ );
+ if native_sequence {
+ vm.dispatch_prepared_element_click(click).unwrap();
+ } else {
+ // Compare to the existing independent pointer phases. Their hover
+ // transitions can invalidate layout; preparation must not add more.
+ for (event, buttons) in [("mousemove", 0), ("mousedown", 1), ("mouseup", 0)] {
+ vm.dispatch_mouse_event_at_point_with_pointer(
+ click.root_x,
+ click.root_y,
+ event,
+ 0,
+ Some(buttons),
+ i32::from(event != "mousemove"),
+ 0.0,
+ 0.0,
+ RendererPointerEventProperties::default(),
+ )
+ .unwrap();
+ }
+ }
+ let passes = vm.layout_pass_observability_for_test().1 - before;
+ let events = vm.eval("JSON.stringify([clicks,events])").unwrap();
+ if let Some((existing_passes, existing_events)) = &reference {
+ assert!(passes <= *existing_passes, "extra layout for {mutation}");
+ assert_eq!(&events, existing_events, "{mutation}");
+ } else {
+ reference = Some((passes, events));
+ }
+ }
+ }
+}
+
+#[test]
+fn native_element_click_mock_preparation_does_not_build_layout() {
+ let mut vm = new_parsed_test_vm(
+ "https://click-mock.test/",
+ "<!doctype html><html><body><button id=target>go</button></body></html>",
+ );
+ vm.set_layout_policy(moli_page_types::LayoutPolicy::Mock);
+ let target = vm.document_runtime.get_element_by_id("target").unwrap();
+ let before = vm.layout_pass_observability_for_test().1;
+ assert_eq!(
+ vm.prepare_element_click(target).unwrap(),
+ RendererElementClickTarget::DomActivation
+ );
+ assert_eq!(vm.layout_pass_observability_for_test().1, before);
+}
diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs
index 4577f2271..4cceae269 100644
--- a/moli-renderer-v8/src/script_vm/tests/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs
@@ -15123,6 +15123,7 @@ mod canvas_webgl;
mod child_dynamic_inline_scripts;
mod dom_elements;
mod dom_xhr;
+mod element_click;
mod http_fixture;
mod indexed_db;
mod inspector_unwrap;