servoshell: reduce duplication for conversion between physical/logical position/size (#38082)

With helper functions introduced in #38020, this is now becoming
reality.

Testing: No behaviour change.
Fixes: #37937

Signed-off-by: Euclid Ye <euclid.ye@huawei.com>

ports/servoshell/desktop/app.rs

@@ -21,11 +21,10 @@ 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_geometry::convert_size_to_css_pixel;
 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, ImeEvent, InputEvent, KeyboardEvent, MouseButtonEvent, MouseMoveEvent,
     WebDriverCommandMsg, WebDriverScriptCommand, WebDriverUserPromptAction, WheelDelta, WheelEvent,
@@ -407,29 +406,20 @@ impl App {
                         .values()
                         .next()
                         .expect("Should have at least one window in servoshell");
-                    let scale = window.hidpi_scale_factor().get() as f64;
+                    let scale = window.hidpi_scale_factor();
-                    // TODO: Find a universal way to convert.
+
-                    // See https://github.com/servo/servo/issues/37937
+                    let requested_physical_size =
-                    let requested_physical_size = DeviceIntSize::new(
+                        (requested_size.to_f32() * scale).round().to_i32();
-                        (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_physical_size);
                     // TODO: Handle None case. For now, we assume always succeed.
                     // In reality, the request may exceed available screen 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| {
+                            .map(|size| convert_size_to_css_pixel(size, scale))
-                                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,7 +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::{DeviceIndependentIntRect, DeviceIndependentPixel};
+use servo::servo_geometry::{
+    DeviceIndependentIntRect, DeviceIndependentPixel, convert_rect_to_css_pixel,
+};
 use servo::webrender_api::ScrollLocation;
 use servo::webrender_api::units::{DeviceIntPoint, DeviceIntRect, DeviceIntSize, DevicePixel};
 use servo::{
@@ -495,26 +497,19 @@ impl WindowPortsMethods for Window {
 
     fn window_rect(&self) -> DeviceIndependentIntRect {
         let outer_size = self.winit_window.outer_size();
-        let hidpi_scale = self.hidpi_scale_factor().get() as f64;
+        let scale = self.hidpi_scale_factor();
-        // TODO: Find a universal way to convert.
+
-        // See https://github.com/servo/servo/issues/37937
+        let outer_size = winit_size_to_euclid_size(outer_size).to_i32();
-        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| {
+            .map(winit_position_to_euclid_point)
-                Point2D::new(
-                    (point.x as f64 / hidpi_scale).round() as i32,
-                    (point.y as f64 / hidpi_scale).round() as i32,
-                )
-            })
             .unwrap_or_default();
-        DeviceIndependentIntRect::from_origin_and_size(origin, total_size)
+        convert_rect_to_css_pixel(
+            DeviceIntRect::from_origin_and_size(origin, outer_size),
+            scale,
+        )
     }
 
     fn set_position(&self, point: DeviceIntPoint) {

ports/servoshell/desktop/headless_window.rs

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