paint: Propogate input event dispatch failure to Servo to resolve deadlock (servo#43381)

yezhizhen · web-flow · commit ca898ea99ce5 · 2026-03-23T06:46:21.000Z
`dispatch_input_event_with_hit_testing` already returns a `bool` to indicate whether the dispatch failed. However, for some reason this was used nowhere. When it fails, embedder is not informed. This is fine for embedder as right now it only handles keyboard shortcuts for headed window, but a disaster for WebDriver as it is synchornously waiting for the feedback. Testing: Several tests no longer CRASH. Fixes: servo#43379 --------- Signed-off-by: Euclid Ye <yezhizhenjiakang@gmail.com>
diff --git a/components/paint/paint.rs b/components/paint/paint.rs
@@ -786,12 +786,14 @@ impl Paint {
             .save_capture(capture_path, CaptureBits::all());
     }
 
-    pub fn notify_input_event(&self, webview_id: WebViewId, event: InputEventAndId) {
+    /// Returning `false` means this is not going to reach the Constellation,
+    /// and we need to directly notify the embedder that input event is handled.
+    pub fn notify_input_event(&self, webview_id: WebViewId, event: InputEventAndId) -> bool {
         if self.shutdown_state() != ShutdownState::NotShuttingDown {
-            return;
+            return false;
         }
         self.painter_mut(webview_id.into())
-            .notify_input_event(webview_id, event);
+            .notify_input_event(webview_id, event)
     }
 
     pub fn notify_scroll_event(&self, webview_id: WebViewId, scroll: Scroll, point: WebViewPoint) {
diff --git a/components/paint/painter.rs b/components/paint/painter.rs
@@ -1305,29 +1305,35 @@ impl Painter {
             .unwrap_or(1.)
     }
 
-    pub(crate) fn notify_input_event(&mut self, webview_id: WebViewId, event: InputEventAndId) {
-        if let Some(webview_renderer) = self.webview_renderers.get_mut(&webview_id) {
-            match &event.event {
-                InputEvent::MouseMove(event) => {
-                    // We only track the last mouse move position for non-touch events.
-                    if !event.is_compatibility_event_for_touch {
-                        let event_point = event
-                            .point
-                            .as_device_point(webview_renderer.device_pixels_per_page_pixel());
-                        self.last_mouse_move_position = Some(event_point);
-                    }
-                },
-                InputEvent::MouseLeftViewport(_) => {
-                    self.last_mouse_move_position = None;
-                },
-                _ => {
-                    // Disable LCP calculation on any other input event except mouse moves.
-                    self.lcp_calculator.disable_for_webview(webview_id);
-                },
-            }
+    pub(crate) fn notify_input_event(
+        &mut self,
+        webview_id: WebViewId,
+        event: InputEventAndId,
+    ) -> bool {
+        self.webview_renderers
+            .get_mut(&webview_id)
+            .is_some_and(|webview_renderer| {
+                match &event.event {
+                    InputEvent::MouseMove(event) => {
+                        // We only track the last mouse move position for non-touch events.
+                        if !event.is_compatibility_event_for_touch {
+                            let event_point = event
+                                .point
+                                .as_device_point(webview_renderer.device_pixels_per_page_pixel());
+                            self.last_mouse_move_position = Some(event_point);
+                        }
+                    },
+                    InputEvent::MouseLeftViewport(_) => {
+                        self.last_mouse_move_position = None;
+                    },
+                    _ => {
+                        // Disable LCP calculation on any other input event except mouse moves.
+                        self.lcp_calculator.disable_for_webview(webview_id);
+                    },
+                }
 
-            webview_renderer.notify_input_event(&self.webrender_api, &self.needs_repaint, event);
-        }
+                webview_renderer.notify_input_event(&self.webrender_api, &self.needs_repaint, event)
+            })
     }
 
     pub(crate) fn notify_scroll_event(
diff --git a/components/paint/webview_renderer.rs b/components/paint/webview_renderer.rs
@@ -411,18 +411,17 @@ impl WebViewRenderer {
         render_api: &RenderApi,
         repaint_reason: &Cell<RepaintReason>,
         event_and_id: InputEventAndId,
-    ) {
+    ) -> bool {
         if let InputEvent::Touch(touch_event) = event_and_id.event {
-            self.on_touch_event(render_api, repaint_reason, touch_event, event_and_id.id);
-            return;
+            return self.on_touch_event(render_api, repaint_reason, touch_event, event_and_id.id);
         }
 
         if let InputEvent::Wheel(wheel_event) = event_and_id.event {
             self.pending_wheel_events
                 .insert(event_and_id.id, wheel_event);
         }
 
-        self.dispatch_input_event_with_hit_testing(render_api, event_and_id);
+        self.dispatch_input_event_with_hit_testing(render_api, event_and_id)
     }
 
     fn send_touch_event(
@@ -458,30 +457,41 @@ impl WebViewRenderer {
         repaint_reason: &Cell<RepaintReason>,
         event: TouchEvent,
         id: InputEventId,
-    ) {
-        match event.event_type {
+    ) -> bool {
+        let result = match event.event_type {
             TouchEventType::Down => self.on_touch_down(render_api, event, id),
             TouchEventType::Move => self.on_touch_move(render_api, event, id),
             TouchEventType::Up => self.on_touch_up(render_api, event, id),
             TouchEventType::Cancel => self.on_touch_cancel(render_api, event, id),
-        }
+        };
 
         self.touch_handler
             .add_touch_move_refresh_observer_if_necessary(
                 self.refresh_driver.clone(),
                 repaint_reason,
             );
+        result
     }
 
-    fn on_touch_down(&mut self, render_api: &RenderApi, event: TouchEvent, id: InputEventId) {
+    fn on_touch_down(
+        &mut self,
+        render_api: &RenderApi,
+        event: TouchEvent,
+        id: InputEventId,
+    ) -> bool {
         let point = event
             .point
             .as_device_point(self.device_pixels_per_page_pixel());
         self.touch_handler.on_touch_down(event.touch_id, point);
-        self.send_touch_event(render_api, event, id);
+        self.send_touch_event(render_api, event, id)
     }
 
-    fn on_touch_move(&mut self, render_api: &RenderApi, mut event: TouchEvent, id: InputEventId) {
+    fn on_touch_move(
+        &mut self,
+        render_api: &RenderApi,
+        mut event: TouchEvent,
+        id: InputEventId,
+    ) -> bool {
         let point = event
             .point
             .as_device_point(self.device_pixels_per_page_pixel());
@@ -503,37 +513,45 @@ impl WebViewRenderer {
                 self.pending_scroll_zoom_events.push(action);
             }
         }
+        let mut reached_constellation = false;
         // When the event is touchmove, if the script thread is processing the touch
         // move event, we skip sending the event to the script thread.
         // This prevents the script thread from stacking up for a large amount of time.
         if !self.touch_handler.is_handling_touch_move_for_touch_id(
             self.touch_handler.current_sequence_id,
             event.touch_id,
-        ) && self.send_touch_event(render_api, event, id) &&
-            event.is_cancelable()
-        {
-            self.touch_handler.set_handling_touch_move_for_touch_id(
-                self.touch_handler.current_sequence_id,
-                event.touch_id,
-                TouchIdMoveTracking::Track,
-            );
+        ) {
+            reached_constellation = self.send_touch_event(render_api, event, id);
+            if reached_constellation && event.is_cancelable() {
+                self.touch_handler.set_handling_touch_move_for_touch_id(
+                    self.touch_handler.current_sequence_id,
+                    event.touch_id,
+                    TouchIdMoveTracking::Track,
+                );
+            }
         }
+        reached_constellation
     }
 
-    fn on_touch_up(&mut self, render_api: &RenderApi, event: TouchEvent, id: InputEventId) {
+    fn on_touch_up(&mut self, render_api: &RenderApi, event: TouchEvent, id: InputEventId) -> bool {
         let point = event
             .point
             .as_device_point(self.device_pixels_per_page_pixel());
         self.touch_handler.on_touch_up(event.touch_id, point);
-        self.send_touch_event(render_api, event, id);
+        self.send_touch_event(render_api, event, id)
     }
 
-    fn on_touch_cancel(&mut self, render_api: &RenderApi, event: TouchEvent, id: InputEventId) {
+    fn on_touch_cancel(
+        &mut self,
+        render_api: &RenderApi,
+        event: TouchEvent,
+        id: InputEventId,
+    ) -> bool {
         let point = event
             .point
             .as_device_point(self.device_pixels_per_page_pixel());
         self.touch_handler.on_touch_cancel(event.touch_id, point);
-        self.send_touch_event(render_api, event, id);
+        self.send_touch_event(render_api, event, id)
     }
 
     fn on_touch_event_processed(
diff --git a/components/servo/servo.rs b/components/servo/servo.rs
@@ -134,6 +134,11 @@ enum Message {
     FromUnknown(EmbedderMsg),
 }
 
+pub struct PendingHandledInputEvent {
+    pub event_id: InputEventId,
+    pub webview_id: WebViewId,
+}
+
 struct ServoInner {
     delegate: RefCell<Rc<dyn ServoDelegate>>,
     paint: Rc<RefCell<Paint>>,
@@ -158,6 +163,11 @@ struct ServoInner {
     /// and deinitialization of the JS Engine. Multiprocess Servo instances have their
     /// own instance that exists in the content process instead.
     _js_engine_setup: Option<JSEngineSetup>,
+    /// [`InputEventId`]s that have been handled, but for which the embedder has
+    /// not been notified yet.
+    pending_handled_input_events: RefCell<Vec<PendingHandledInputEvent>>,
+    /// An [`EventLoopWaker`] used to wake up the main embedder event loop.
+    event_loop_waker: Box<dyn EventLoopWaker>,
 }
 
 impl ServoInner {
@@ -197,6 +207,26 @@ impl ServoInner {
                 break;
             }
         }
+        let pending_handled_input_events =
+            std::mem::take(&mut *self.pending_handled_input_events.borrow_mut());
+        for PendingHandledInputEvent {
+            event_id,
+            webview_id,
+        } in pending_handled_input_events
+        {
+            self.paint.borrow_mut().notify_input_event_handled(
+                webview_id,
+                event_id,
+                InputEventResult::DispatchFailed,
+            );
+            if let Some(webview) = self.get_webview_handle(webview_id) {
+                webview.delegate().notify_input_event_handled(
+                    webview,
+                    event_id,
+                    InputEventResult::DispatchFailed,
+                );
+            }
+        }
 
         if self.constellation_proxy.disconnected() {
             self.delegate
@@ -798,7 +828,7 @@ impl Servo {
             time_profiler_chan: time_profiler_chan.clone(),
             mem_profiler_chan: mem_profiler_chan.clone(),
             shutdown_state: shutdown_state.clone(),
-            event_loop_waker,
+            event_loop_waker: event_loop_waker.clone(),
             #[cfg(feature = "webxr")]
             webxr_registry: builder.webxr_registry,
         });
@@ -862,6 +892,8 @@ impl Servo {
             webviews: Default::default(),
             servo_errors: ServoErrorChannel::default(),
             _js_engine_setup: js_engine_setup,
+            pending_handled_input_events: Default::default(),
+            event_loop_waker,
         }))
     }
 
@@ -935,6 +967,10 @@ impl Servo {
         self.0.paint.borrow_mut()
     }
 
+    pub(crate) fn event_loop_waker(&self) -> &dyn EventLoopWaker {
+        &*self.0.event_loop_waker
+    }
+
     pub(crate) fn webviews_mut<'a>(
         &'a self,
     ) -> RefMut<'a, FxHashMap<WebViewId, Weak<RefCell<WebViewInner>>>> {
@@ -948,6 +984,13 @@ impl Servo {
     pub(crate) fn javascript_evaluator_mut<'a>(&'a self) -> RefMut<'a, JavaScriptEvaluator> {
         self.0.javascript_evaluator.borrow_mut()
     }
+
+    pub(crate) fn add_pending_handled_input_event(&self, residue_event: PendingHandledInputEvent) {
+        self.0
+            .pending_handled_input_events
+            .borrow_mut()
+            .push(residue_event);
+    }
 }
 
 fn create_embedder_channel(
diff --git a/components/servo/webview.rs b/components/servo/webview.rs
@@ -32,6 +32,7 @@ use crate::clipboard_delegate::{ClipboardDelegate, DefaultClipboardDelegate};
 #[cfg(feature = "gamepad")]
 use crate::gamepad_delegate::{DefaultGamepadDelegate, GamepadDelegate};
 use crate::responders::IpcResponder;
+use crate::servo::PendingHandledInputEvent;
 use crate::webview_delegate::{CreateNewWebViewRequest, DefaultWebViewDelegate, WebViewDelegate};
 use crate::{
     ColorPicker, ContextMenu, EmbedderControl, InputMethodControl, SelectElement, Servo,
@@ -502,21 +503,23 @@ impl WebView {
     pub fn notify_input_event(&self, event: InputEvent) -> InputEventId {
         let event: InputEventAndId = event.into();
         let event_id = event.id;
-
+        let webview_id = self.id();
+        let servo = &self.inner().servo;
         // Events with a `point` first go to `Paint` for hit testing.
         if event.event.point().is_some() {
-            self.inner()
-                .servo
-                .paint()
-                .notify_input_event(self.id(), event);
+            if !servo.paint().notify_input_event(self.id(), event) {
+                servo.add_pending_handled_input_event(PendingHandledInputEvent {
+                    event_id,
+                    webview_id,
+                });
+                servo.event_loop_waker().wake();
+            }
         } else {
-            self.inner().servo.constellation_proxy().send(
-                EmbedderToConstellationMessage::ForwardInputEvent(
-                    self.id(),
-                    event,
-                    None, /* hit_test */
-                ),
-            );
+            servo
+                .constellation_proxy()
+                .send(EmbedderToConstellationMessage::ForwardInputEvent(
+                    webview_id, event, None, /* hit_test */
+                ));
         }
 
         event_id
diff --git a/components/shared/embedder/input_events.rs b/components/shared/embedder/input_events.rs
@@ -33,6 +33,10 @@ bitflags! {
         /// behavior (such as keybindings) when the WebView has already consumed the event for its
         /// own purpose.
         const Consumed = 1 << 1;
+        /// Whether or not the input event failed to dispatch. This can happen when an event
+        /// is sent while Servo is shutting down or when it is in an intermediate state.
+        /// Typically these events should be considered to be consumed.
+        const DispatchFailed = 1 << 2;
     }
 }
 
diff --git a/tests/wpt/meta/css/cssom-view/visual-scrollIntoView-001.html.ini b/tests/wpt/meta/css/cssom-view/visual-scrollIntoView-001.html.ini
@@ -1,4 +1,4 @@
 [visual-scrollIntoView-001.html]
-  expected: CRASH
+  expected: TIMEOUT
   [Element.scrollIntoView scrolls visually]
-    expected: FAIL
+    expected: TIMEOUT
diff --git a/tests/wpt/meta/css/cssom-view/visual-scrollIntoView-002.html.ini b/tests/wpt/meta/css/cssom-view/visual-scrollIntoView-002.html.ini
@@ -1,4 +1,4 @@
 [visual-scrollIntoView-002.html]
-  expected: CRASH
+  expected: TIMEOUT
   [Element.scrollIntoView scrolls visually to a position: fixed element with non-zero layout scroll offset]
-    expected: FAIL
+    expected: TIMEOUT
diff --git a/tests/wpt/meta/css/cssom-view/visual-scrollIntoView-003.html.ini b/tests/wpt/meta/css/cssom-view/visual-scrollIntoView-003.html.ini
@@ -1,4 +1,4 @@
 [visual-scrollIntoView-003.html]
-  expected: CRASH
+  expected: TIMEOUT
   [Element.scrollIntoView scrolls visually to an element in nested position: fixed elements]
-    expected: FAIL
+    expected: TIMEOUT
diff --git a/tests/wpt/meta/css/selectors/focus-visible-018-2.html.ini b/tests/wpt/meta/css/selectors/focus-visible-018-2.html.ini
@@ -1,5 +1,5 @@
 [focus-visible-018-2.html]
-  expected: CRASH
+  expected: TIMEOUT
   [Mouse focus does not show a focus ring by default in element TABLE]
     expected: TIMEOUT
 
diff --git a/tests/wpt/meta/dom/events/scrolling/scrollend-event-fires-on-visual-viewport.html.ini b/tests/wpt/meta/dom/events/scrolling/scrollend-event-fires-on-visual-viewport.html.ini
@@ -1,2 +1,10 @@
 [scrollend-event-fires-on-visual-viewport.html]
-  expected: CRASH
+  expected: TIMEOUT
+  [scrollend listener added via addEventlistener fires when the visual viewport is panned.]
+    expected: TIMEOUT
+
+  [visualviewport.onscrollend fires when the visual viewport is panned.]
+    expected: NOTRUN
+
+  [visualviewport.onscrollend  and window scrollend order.]
+    expected: NOTRUN
diff --git a/tests/wpt/meta/fullscreen/rendering/fullscreen-root-fills-page.html.ini b/tests/wpt/meta/fullscreen/rendering/fullscreen-root-fills-page.html.ini
@@ -1,2 +1,2 @@
 [fullscreen-root-fills-page.html]
-  expected: CRASH
+  expected: TIMEOUT
diff --git a/tests/wpt/meta/touch-events/multi-touch-interactions.html.ini b/tests/wpt/meta/touch-events/multi-touch-interactions.html.ini
diff --git a/tests/wpt/meta/visual-viewport/page-and-offset-in-iframe.html.ini b/tests/wpt/meta/visual-viewport/page-and-offset-in-iframe.html.ini
diff --git a/tests/wpt/meta/visual-viewport/scroll-event-order.html.ini b/tests/wpt/meta/visual-viewport/scroll-event-order.html.ini

Original file line number	Diff line number	Diff line change
`@@ -786,12 +786,14 @@ impl Paint {`
`786`	`786`	`.save_capture(capture_path, CaptureBits::all());`
`787`	`787`	`}`
`788`	`788`
`789`		`- pub fn notify_input_event(&self, webview_id: WebViewId, event: InputEventAndId) {`
	`789`	+ /// Returning `false` means this is not going to reach the Constellation,
	`790`	`+ /// and we need to directly notify the embedder that input event is handled.`
	`791`	`+ pub fn notify_input_event(&self, webview_id: WebViewId, event: InputEventAndId) -> bool {`
`790`	`792`	`if self.shutdown_state() != ShutdownState::NotShuttingDown {`
`791`		`- return;`
	`793`	`+ return false;`
`792`	`794`	`}`
`793`	`795`	`self.painter_mut(webview_id.into())`
`794`		`- .notify_input_event(webview_id, event);`
	`796`	`+ .notify_input_event(webview_id, event)`
`795`	`797`	`}`
`796`	`798`
`797`	`799`	`pub fn notify_scroll_event(&self, webview_id: WebViewId, scroll: Scroll, point: WebViewPoint) {`
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,10 @@ bitflags! {`
`33`	`33`	`/// behavior (such as keybindings) when the WebView has already consumed the event for its`
`34`	`34`	`/// own purpose.`
`35`	`35`	`const Consumed = 1 << 1;`
	`36`	`+ /// Whether or not the input event failed to dispatch. This can happen when an event`
	`37`	`+ /// is sent while Servo is shutting down or when it is in an intermediate state.`
	`38`	`+ /// Typically these events should be considered to be consumed.`
	`39`	`+ const DispatchFailed = 1 << 2;`
`36`	`40`	`}`
`37`	`41`	`}`
`38`	`42`