Update window.screenX and window.screenY when moving the embedder window (#35246)

Signed-off-by: webbeef <me@webbeef.org>

components/compositing/compositor.rs

@@ -1290,6 +1290,10 @@ impl IOCompositor {
         self.pipeline_details.remove(&pipeline_id);
     }
 
+    pub fn on_embedder_window_moved(&mut self) {
+        self.embedder_coordinates = self.window.get_coordinates();
+    }
+
     pub fn on_rendering_context_resized(&mut self) -> bool {
         if self.shutdown_state != ShutdownState::NotShuttingDown {
             return false;

components/servo/webview.rs

@@ -352,6 +352,13 @@ impl WebView {
             .on_rendering_context_resized();
     }
 
+    pub fn notify_embedder_window_moved(&self) {
+        self.inner()
+            .compositor
+            .borrow_mut()
+            .on_embedder_window_moved();
+    }
+
     pub fn set_zoom(&self, new_zoom: f32) {
         self.inner()
             .compositor

ports/servoshell/desktop/app.rs

@@ -391,7 +391,7 @@ impl ApplicationHandler<WakerEvent> for App {
         };
 
         let window = window.clone();
-        if event == winit::event::WindowEvent::RedrawRequested {
+        if event == WindowEvent::RedrawRequested {
             // We need to redraw the window for some reason.
             trace!("RedrawRequested");
 
@@ -441,7 +441,7 @@ impl ApplicationHandler<WakerEvent> for App {
                             "Sync WebView size with Window Resize event",
                         );
                     }
-                    if response.repaint && *event != winit::event::WindowEvent::RedrawRequested {
+                    if response.repaint && *event != WindowEvent::RedrawRequested {
                         // Request a winit redraw event, so we can recomposite, update and paint
                         // the minibrowser, and present the new frame.
                         window.winit_window().unwrap().request_redraw();

ports/servoshell/desktop/headed_window.rs

@@ -31,7 +31,9 @@ use servo::{
 use surfman::{Context, Device, SurfaceType};
 use url::Url;
 use winit::dpi::{LogicalSize, PhysicalPosition, PhysicalSize};
-use winit::event::{ElementState, KeyEvent, MouseButton, MouseScrollDelta, TouchPhase};
+use winit::event::{
+    ElementState, KeyEvent, MouseButton, MouseScrollDelta, TouchPhase, WindowEvent,
+};
 use winit::event_loop::ActiveEventLoop;
 use winit::keyboard::{Key as LogicalKey, ModifiersState, NamedKey};
 #[cfg(any(target_os = "linux", target_os = "windows"))]
@@ -245,8 +247,8 @@ impl Window {
     fn handle_mouse(
         &self,
         webview: &WebView,
-        button: winit::event::MouseButton,
+        button: MouseButton,
-        action: winit::event::ElementState,
+        action: ElementState,
         coords: Point2D<i32, DevicePixel>,
     ) {
         let max_pixel_dist = 10.0 * self.hidpi_factor().get();
@@ -533,31 +535,27 @@ impl WindowPortsMethods for Window {
         self.winit_window.id()
     }
 
-    fn handle_winit_event(&self, state: Rc<RunningAppState>, event: winit::event::WindowEvent) {
+    fn handle_winit_event(&self, state: Rc<RunningAppState>, event: WindowEvent) {
         let Some(webview) = state.focused_webview() else {
             return;
         };
 
         match event {
-            winit::event::WindowEvent::KeyboardInput { event, .. } => {
+            WindowEvent::KeyboardInput { event, .. } => self.handle_keyboard_input(state, event),
-                self.handle_keyboard_input(state, event)
+            WindowEvent::ModifiersChanged(modifiers) => self.modifiers_state.set(modifiers.state()),
-            },
+            WindowEvent::MouseInput { state, button, .. } => {
-            winit::event::WindowEvent::ModifiersChanged(modifiers) => {
-                self.modifiers_state.set(modifiers.state())
-            },
-            winit::event::WindowEvent::MouseInput { state, button, .. } => {
                 if button == MouseButton::Left || button == MouseButton::Right {
                     self.handle_mouse(&webview, button, state, self.mouse_pos.get());
                 }
             },
-            winit::event::WindowEvent::CursorMoved { position, .. } => {
+            WindowEvent::CursorMoved { position, .. } => {
                 let position = winit_position_to_euclid_point(position);
                 self.mouse_pos.set(position.to_i32());
                 webview.notify_input_event(InputEvent::MouseMove(MouseMoveEvent {
                     point: position.to_f32(),
                 }));
             },
-            winit::event::WindowEvent::MouseWheel { delta, phase, .. } => {
+            WindowEvent::MouseWheel { delta, phase, .. } => {
                 let (mut dx, mut dy, mode) = match delta {
                     MouseScrollDelta::LineDelta(dx, dy) => {
                         (dx as f64, (dy * LINE_HEIGHT) as f64, WheelMode::DeltaLine)
@@ -594,38 +592,41 @@ impl WindowPortsMethods for Window {
                 webview.notify_input_event(InputEvent::Wheel(WheelEvent { delta, point }));
                 webview.notify_scroll_event(scroll_location, self.mouse_pos.get(), phase);
             },
-            winit::event::WindowEvent::Touch(touch) => {
+            WindowEvent::Touch(touch) => {
                 webview.notify_input_event(InputEvent::Touch(TouchEvent {
                     action: winit_phase_to_touch_event_action(touch.phase),
                     id: TouchId(touch.id as i32),
                     point: Point2D::new(touch.location.x as f32, touch.location.y as f32),
                 }));
             },
-            winit::event::WindowEvent::PinchGesture { delta, .. } => {
+            WindowEvent::PinchGesture { delta, .. } => {
                 webview.set_pinch_zoom(delta as f32 + 1.0);
             },
-            winit::event::WindowEvent::CloseRequested => {
+            WindowEvent::CloseRequested => {
                 state.servo().start_shutting_down();
             },
-            winit::event::WindowEvent::Resized(new_size) => {
+            WindowEvent::Resized(new_size) => {
                 if self.inner_size.get() != new_size {
                     self.inner_size.set(new_size);
                     webview.notify_rendering_context_resized();
                 }
             },
-            winit::event::WindowEvent::ThemeChanged(theme) => {
+            WindowEvent::ThemeChanged(theme) => {
                 webview.notify_theme_change(match theme {
                     winit::window::Theme::Light => Theme::Light,
                     winit::window::Theme::Dark => Theme::Dark,
                 });
             },
+            WindowEvent::Moved(_new_position) => {
+                webview.notify_embedder_window_moved();
+            },
             _ => {},
         }
     }
 
     fn new_glwindow(
         &self,
-        event_loop: &winit::event_loop::ActiveEventLoop,
+        event_loop: &ActiveEventLoop,
     ) -> Rc<dyn servo::webxr::glwindow::GlWindow> {
         let size = self.winit_window.outer_size();
 
@@ -800,7 +801,7 @@ impl XRWindowPose {
     }
 
     fn handle_xr_rotation(&self, input: &KeyEvent, modifiers: ModifiersState) {
-        if input.state != winit::event::ElementState::Pressed {
+        if input.state != ElementState::Pressed {
             return;
         }
         let mut x = 0.0;