libservo: Have wheel events trigger scroll in Servo (servo#40269)

Instead of forcing embedders to implement scrolling when wheel events
happen, have Servo take care of this. This means that scrolling happens
consistently with wheel events across all embedders.

Testing: This is tested by the WebDriver conformance suite.

Signed-off-by: Martin Robinson <[email protected]>
Co-authored-by: atbrakhi <[email protected]>

Author: mrobinson

components/compositing/webview_renderer.rs

@@ -17,6 +17,7 @@ use embedder_traits::{
     AnimationState, CompositorHitTestResult, InputEvent, InputEventAndId, InputEventId,
     InputEventResult, MouseButton, MouseButtonAction, MouseButtonEvent, MouseMoveEvent, Scroll,
     ScrollEvent as EmbedderScrollEvent, TouchEvent, TouchEventType, ViewportDetails, WebViewPoint,
+    WheelEvent,
 };
 use euclid::{Scale, Vector2D};
 use log::{debug, warn};
@@ -25,7 +26,7 @@ use rustc_hash::FxHashMap;
 use servo_geometry::DeviceIndependentPixel;
 use style_traits::CSSPixel;
 use webrender::RenderApi;
-use webrender_api::units::{DevicePixel, DevicePoint, DeviceRect, LayoutVector2D};
+use webrender_api::units::{DevicePixel, DevicePoint, DeviceRect, DeviceVector2D, LayoutVector2D};
 use webrender_api::{DocumentId, ExternalScrollId, ScrollLocation};
 
 use crate::painter::Painter;
@@ -359,9 +360,28 @@ impl WebViewRenderer {
             return;
         }
 
+        if let InputEvent::Wheel(wheel_event) = event_and_id.event {
+            self.on_wheel_event(render_api, wheel_event, event_and_id);
+            return;
+        }
+
         self.dispatch_input_event_with_hit_testing(render_api, event_and_id);
     }
 
+    fn on_wheel_event(
+        &mut self,
+        render_api: &RenderApi,
+        wheel_event: WheelEvent,
+        event_and_id: InputEventAndId,
+    ) {
+        self.dispatch_input_event_with_hit_testing(render_api, event_and_id);
+
+        // A scroll delta for a wheel event is the inverse of the wheel delta.
+        let scroll_delta =
+            DeviceVector2D::new(-wheel_event.delta.x as f32, -wheel_event.delta.y as f32);
+        self.notify_scroll_event(Scroll::Delta(scroll_delta.into()), wheel_event.point);
+    }
+
     fn send_touch_event(
         &mut self,
         render_api: &RenderApi,

components/servo/examples/winit_minimal.rs

@@ -8,11 +8,12 @@ use std::rc::Rc;
 
 use euclid::{Scale, Size2D};
 use servo::{
-    RenderingContext, Scroll, Servo, ServoBuilder, WebView, WebViewBuilder, WindowRenderingContext,
+    InputEvent, RenderingContext, Servo, ServoBuilder, WebView, WebViewBuilder, WheelDelta,
+    WheelEvent, WheelMode, WindowRenderingContext,
 };
 use tracing::warn;
 use url::Url;
-use webrender_api::units::{DevicePixel, DevicePoint, LayoutVector2D};
+use webrender_api::units::{DevicePixel, DevicePoint};
 use winit::application::ApplicationHandler;
 use winit::dpi::PhysicalSize;
 use winit::event::{MouseScrollDelta, WindowEvent};
@@ -151,18 +152,24 @@ impl ApplicationHandler<WakerEvent> for App {
             WindowEvent::MouseWheel { delta, .. } => {
                 if let Self::Running(state) = self {
                     if let Some(webview) = state.webviews.borrow().last() {
-                        let moved_by = match delta {
-                            MouseScrollDelta::LineDelta(horizontal, vertical) => {
-                                LayoutVector2D::new(20. * horizontal, 20. * vertical)
+                        let (delta_x, delta_y, mode) = match delta {
+                            MouseScrollDelta::LineDelta(dx, dy) => {
+                                ((dx * 76.0) as f64, (dy * 76.0) as f64, WheelMode::DeltaLine)
                             },
-                            MouseScrollDelta::PixelDelta(pos) => {
-                                LayoutVector2D::new(pos.x as f32, pos.y as f32)
+                            MouseScrollDelta::PixelDelta(delta) => {
+                                (delta.x, delta.y, WheelMode::DeltaPixel)
                             },
                         };
-                        webview.notify_scroll_event(
-                            Scroll::Delta(moved_by.into()),
-                            DevicePoint::new(10.0, 10.0).into(),
-                        );
+
+                        webview.notify_input_event(InputEvent::Wheel(WheelEvent::new(
+                            WheelDelta {
+                                x: delta_x,
+                                y: delta_y,
+                                z: 0.0,
+                                mode,
+                            },
+                            DevicePoint::default().into(),
+                        )));
                     }
                 }
             },

ports/servoshell/desktop/headed_window.rs

@@ -21,13 +21,13 @@ use servo::servo_geometry::{
     DeviceIndependentIntRect, DeviceIndependentPixel, convert_rect_to_css_pixel,
 };
 use servo::webrender_api::units::{
-    DeviceIntPoint, DeviceIntRect, DeviceIntSize, DevicePixel, DevicePoint, DeviceVector2D,
+    DeviceIntPoint, DeviceIntRect, DeviceIntSize, DevicePixel, DevicePoint,
 };
 use servo::{
     Cursor, ImeEvent, InputEvent, InputEventId, InputEventResult, InputMethodControl, Key,
     KeyState, KeyboardEvent, Modifiers, MouseButton as ServoMouseButton, MouseButtonAction,
     MouseButtonEvent, MouseLeftViewportEvent, MouseMoveEvent, NamedKey, OffscreenRenderingContext,
-    RenderingContext, ScreenGeometry, Scroll, Theme, TouchEvent, TouchEventType, TouchId,
+    RenderingContext, ScreenGeometry, Theme, TouchEvent, TouchEventType, TouchId,
     WebRenderDebugOption, WebView, WheelDelta, WheelEvent, WheelMode, WindowRenderingContext,
 };
 use url::Url;
@@ -50,7 +50,7 @@ use {
 use super::app_state::RunningAppState;
 use super::geometry::{winit_position_to_euclid_point, winit_size_to_euclid_size};
 use super::keyutils::{CMD_OR_ALT, keyboard_event_from_winit};
-use super::window_trait::{LINE_HEIGHT, LINE_WIDTH, PIXEL_DELTA_FACTOR, WindowPortsMethods};
+use super::window_trait::{LINE_HEIGHT, LINE_WIDTH, WindowPortsMethods};
 use crate::desktop::accelerated_gl_media::setup_gl_accelerated_media;
 use crate::desktop::keyutils::CMD_OR_CONTROL;
 use crate::desktop::window_trait::MIN_WINDOW_INNER_SIZE;
@@ -650,44 +650,26 @@ impl WindowPortsMethods for Window {
                 }
             },
             WindowEvent::MouseWheel { delta, .. } => {
-                let (mut dx, mut dy, mode) = match delta {
-                    MouseScrollDelta::LineDelta(dx, dy) => (
-                        (dx * LINE_WIDTH) as f64,
-                        (dy * LINE_HEIGHT) as f64,
+                let (delta_x, delta_y, mode) = match delta {
+                    MouseScrollDelta::LineDelta(delta_x, delta_y) => (
+                        (delta_x * LINE_WIDTH) as f64,
+                        (delta_y * LINE_HEIGHT) as f64,
                         WheelMode::DeltaLine,
                     ),
-                    MouseScrollDelta::PixelDelta(position) => {
-                        let position: LogicalPosition<f64> =
-                            position.to_logical(self.device_hidpi_scale_factor().get() as f64);
-                        (
-                            position.x * PIXEL_DELTA_FACTOR,
-                            position.y * PIXEL_DELTA_FACTOR,
-                            WheelMode::DeltaPixel,
-                        )
+                    MouseScrollDelta::PixelDelta(delta) => {
+                        (delta.x, delta.y, WheelMode::DeltaPixel)
                     },
                 };
 
                 // Create wheel event before snapping to the major axis of movement
                 let delta = WheelDelta {
-                    x: dx,
-                    y: dy,
+                    x: delta_x,
+                    y: delta_y,
                     z: 0.0,
                     mode,
                 };
                 let point = self.webview_relative_mouse_point.get();
-
-                // Scroll events snap to the major axis of movement, with vertical
-                // preferred over horizontal.
-                if dy.abs() >= dx.abs() {
-                    dx = 0.0;
-                } else {
-                    dy = 0.0;
-                }
-
-                // Send events
                 webview.notify_input_event(InputEvent::Wheel(WheelEvent::new(delta, point.into())));
-                let scroll = Scroll::Delta((-DeviceVector2D::new(dx as f32, dy as f32)).into());
-                webview.notify_scroll_event(scroll, point.into());
             },
             WindowEvent::Touch(touch) => {
                 webview.notify_input_event(InputEvent::Touch(TouchEvent::new(

ports/servoshell/desktop/window_trait.rs

@@ -21,11 +21,6 @@ use super::app_state::RunningAppState;
 pub(crate) const LINE_HEIGHT: f32 = 76.0;
 pub(crate) const LINE_WIDTH: f32 = 76.0;
 
-// MouseScrollDelta::PixelDelta is default for MacOS, which is high precision and very slow
-// in winit. Therefore we use a factor of 4.0 to make it more usable.
-// See https://github.com/servo/servo/pull/34063#discussion_r2197729507
-pub(crate) const PIXEL_DELTA_FACTOR: f64 = 4.0;
-
 /// <https://github.com/web-platform-tests/wpt/blob/9320b1f724632c52929a3fdb11bdaf65eafc7611/webdriver/tests/classic/set_window_rect/set.py#L287-L290>
 /// "A window size of 10x10px shouldn't be supported by any browser."
 pub(crate) const MIN_WINDOW_INNER_SIZE: DeviceIntSize = DeviceIntSize::new(100, 100);

ports/servoshell/running_app_state.rs

@@ -11,10 +11,9 @@ use crossbeam_channel::Sender;
 use servo::base::generic_channel::GenericSender;
 use servo::base::id::WebViewId;
 use servo::ipc_channel::ipc::IpcSender;
-use servo::webrender_api::units::DeviceVector2D;
 use servo::{
-    InputEvent, InputEventId, Scroll, TraversalId, WebDriverJSResult, WebDriverLoadStatus,
-    WebDriverSenders, WebView, WheelEvent,
+    InputEvent, InputEventId, TraversalId, WebDriverJSResult, WebDriverLoadStatus,
+    WebDriverSenders, WebView,
 };
 
 pub struct RunningAppStateBase {
@@ -86,27 +85,12 @@ pub trait RunningAppStateTrait {
         input_event: InputEvent,
         response_sender: Option<Sender<()>>,
     ) {
-        // TODO: Scroll events triggered by wheel events should happen as
-        // a default event action in the compositor.
-        let scroll_event = match &input_event {
-            InputEvent::Wheel(WheelEvent { delta, point }) => {
-                let scroll =
-                    Scroll::Delta(DeviceVector2D::new(-delta.x as f32, -delta.y as f32).into());
-                Some((scroll, *point))
-            },
-            _ => None,
-        };
-
         let event_id = webview.notify_input_event(input_event);
         if let Some(response_sender) = response_sender {
             self.base()
                 .pending_webdriver_events
                 .borrow_mut()
                 .insert(event_id, response_sender);
         }
-
-        if let Some((scroll, scroll_point)) = scroll_event {
-            webview.notify_scroll_event(scroll, scroll_point);
-        }
     }
 }