servoshell: Use DeviceIndependentPixel for WebDriver Rect related requests (#37893)

[Spec](https://w3c.github.io/webdriver/#set-window-rect) expects CSS
pixel for input and output. Previously, we use Device Pixel for them
instead.

Testing: Tested manually with different screen DPR and compared with
other browsers.
Fixes: Task 4 of https://github.com/servo/servo/issues/37804

---------

Signed-off-by: Euclid Ye <yezhizhenjiakang@gmail.com>

ports/servoshell/desktop/app.rs

@@ -20,9 +20,11 @@ use log::{info, trace, warn};
 use net::protocols::ProtocolRegistry;
 use servo::config::opts::Opts;
 use servo::config::prefs::Preferences;
+use servo::servo_geometry::DeviceIndependentIntSize;
 use servo::servo_url::ServoUrl;
 use servo::user_content_manager::{UserContentManager, UserScript};
 use servo::webrender_api::ScrollLocation;
+use servo::webrender_api::units::DeviceIntSize;
 use servo::{
     EventLoopWaker, InputEvent, KeyboardEvent, MouseButtonEvent, MouseMoveEvent,
     WebDriverCommandMsg, WheelDelta, WheelEvent, WheelMode,
@@ -403,13 +405,31 @@ impl App {
                         .values()
                         .next()
                         .expect("Should have at least one window in servoshell");
-
+                    let scale = window.hidpi_scale_factor().get() as f64;
+                    // TODO: Find a universal way to convert.
+                    // See https://github.com/servo/servo/issues/37937
+                    let requested_physical_size = DeviceIntSize::new(
+                        (requested_size.width as f64 * scale).round() as i32,
+                        (requested_size.height as f64 * scale).round() as i32,
+                    );
                     // When None is returned, it means that the request went to the display system,
                     // and the actual size will be delivered later with the WindowEvent::Resized.
-                    let returned_size = window.request_resize(&webview, requested_size);
+                    let returned_size = window.request_resize(&webview, requested_physical_size);
                     // TODO: Handle None case. For now, we assume always succeed.
                     // In reality, the request may exceed available screen size.
-                    if let Err(error) = size_sender.send(returned_size.unwrap_or(requested_size)) {
+
+                    // TODO: Find a universal way to convert.
+                    // See https://github.com/servo/servo/issues/37937
+                    if let Err(error) = size_sender.send(
+                        returned_size
+                            .map(|size| {
+                                DeviceIndependentIntSize::new(
+                                    (size.width as f64 / scale).round() as i32,
+                                    (size.height as f64 / scale).round() as i32,
+                                )
+                            })
+                            .unwrap_or(requested_size),
+                    ) {
                         warn!("Failed to send window size: {error}");
                     }
                 },

ports/servoshell/desktop/headed_window.rs

@@ -15,9 +15,9 @@ use keyboard_types::{Modifiers, ShortcutMatcher};
 use log::{debug, info};
 use raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawWindowHandle};
 use servo::servo_config::pref;
-use servo::servo_geometry::DeviceIndependentPixel;
+use servo::servo_geometry::{DeviceIndependentIntRect, DeviceIndependentPixel};
 use servo::webrender_api::ScrollLocation;
-use servo::webrender_api::units::{DeviceIntPoint, DeviceIntRect, DeviceIntSize, DevicePixel};
+use servo::webrender_api::units::{DeviceIntPoint, DeviceIntSize, DevicePixel};
 use servo::{
     Cursor, ImeEvent, InputEvent, Key, KeyState, KeyboardEvent, MouseButton as ServoMouseButton,
     MouseButtonAction, MouseButtonEvent, MouseLeaveEvent, MouseMoveEvent,
@@ -484,15 +484,28 @@ impl WindowPortsMethods for Window {
             })
     }
 
-    fn window_rect(&self) -> DeviceIntRect {
+    fn window_rect(&self) -> DeviceIndependentIntRect {
         let outer_size = self.winit_window.outer_size();
-        let total_size = Size2D::new(outer_size.width as i32, outer_size.height as i32);
+        let hidpi_scale = self.hidpi_scale_factor().get() as f64;
+        // TODO: Find a universal way to convert.
+        // See https://github.com/servo/servo/issues/37937
+        let total_size = Size2D::new(
+            (outer_size.width as f64 / hidpi_scale).round() as i32,
+            (outer_size.height as f64 / hidpi_scale).round() as i32,
+        );
+        // TODO: Find a universal way to convert.
+        // See https://github.com/servo/servo/issues/37937
         let origin = self
             .winit_window
             .outer_position()
-            .map(|point| Point2D::new(point.x, point.y))
+            .map(|point| {
+                Point2D::new(
+                    (point.x as f64 / hidpi_scale).round() as i32,
+                    (point.y as f64 / hidpi_scale).round() as i32,
+                )
+            })
             .unwrap_or_default();
-        DeviceIntRect::from_origin_and_size(origin, total_size)
+        DeviceIndependentIntRect::from_origin_and_size(origin, total_size)
     }
 
     fn set_position(&self, point: DeviceIntPoint) {

ports/servoshell/desktop/headless_window.rs

@@ -9,8 +9,8 @@ use std::rc::Rc;
 
 use euclid::num::Zero;
 use euclid::{Length, Point2D, Scale, Size2D};
-use servo::servo_geometry::DeviceIndependentPixel;
-use servo::webrender_api::units::{DeviceIntRect, DeviceIntSize, DevicePixel};
+use servo::servo_geometry::{DeviceIndependentIntRect, DeviceIndependentPixel};
+use servo::webrender_api::units::{DeviceIntSize, DevicePixel};
 use servo::{RenderingContext, ScreenGeometry, SoftwareRenderingContext};
 use winit::dpi::PhysicalSize;
 
@@ -135,8 +135,18 @@ impl WindowPortsMethods for Window {
         Length::zero()
     }
 
-    fn window_rect(&self) -> DeviceIntRect {
-        DeviceIntRect::from_origin_and_size(Point2D::zero(), self.inner_size.get())
+    fn window_rect(&self) -> DeviceIndependentIntRect {
+        let inner_size = self.inner_size.get().to_f64();
+        let scale = self.hidpi_scale_factor().get() as f64;
+        // TODO: Find a universal way to convert.
+        // See https://github.com/servo/servo/issues/37937
+        DeviceIndependentIntRect::from_origin_and_size(
+            Point2D::zero(),
+            Size2D::new(
+                (inner_size.width / scale).round() as i32,
+                (inner_size.height / scale).round() as i32,
+            ),
+        )
     }
 
     fn set_toolbar_height(&self, _height: Length<f32, DeviceIndependentPixel>) {

ports/servoshell/desktop/window_trait.rs

@@ -8,8 +8,8 @@
 use std::rc::Rc;
 
 use euclid::{Length, Scale};
-use servo::servo_geometry::DeviceIndependentPixel;
-use servo::webrender_api::units::{DeviceIntPoint, DeviceIntRect, DeviceIntSize, DevicePixel};
+use servo::servo_geometry::{DeviceIndependentIntRect, DeviceIndependentPixel};
+use servo::webrender_api::units::{DeviceIntPoint, DeviceIntSize, DevicePixel};
 use servo::{Cursor, RenderingContext, ScreenGeometry, WebView};
 
 use super::app_state::RunningAppState;
@@ -53,5 +53,5 @@ pub trait WindowPortsMethods {
     fn theme(&self) -> servo::Theme {
         servo::Theme::Light
     }
-    fn window_rect(&self) -> DeviceIntRect;
+    fn window_rect(&self) -> DeviceIndependentIntRect;
 }