Rename Window::set_inner_size to Window::request_inner_size

Some systems could resize the window immediately and we'd rather
inform the users right away if that was the case, so they could
create e.g. EGLSurface without waiting for resize, which is really
important for Wayland.

Fixes #2868.

src/platform_impl/android/mod.rs

@@ -802,8 +802,8 @@ impl Window {
         self.outer_size()
     }
 
-    pub fn set_inner_size(&self, _size: Size) {
-        warn!("Cannot set window size on Android");
+    pub fn request_inner_size(&self, _size: Size) -> Option<PhysicalSize<u32>> {
+        Some(self.inner_size())
     }
 
     pub fn outer_size(&self) -> PhysicalSize<u32> {

src/platform_impl/ios/window.rs

@@ -139,8 +139,8 @@ impl Inner {
         }
     }
 
-    pub fn set_inner_size(&self, _size: Size) {
-        warn!("not clear what `Window::set_inner_size` means on iOS");
+    pub fn request_inner_size(&self, _size: Size) -> Option<PhysicalSize<u32>> {
+        Some(self.inner_size())
     }
 
     pub fn set_min_inner_size(&self, _dimensions: Option<Size>) {

src/platform_impl/linux/mod.rs

@@ -367,8 +367,8 @@ impl Window {
     }
 
     #[inline]
-    pub fn set_inner_size(&self, size: Size) {
-        x11_or_wayland!(match self; Window(w) => w.set_inner_size(size))
+    pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
+        x11_or_wayland!(match self; Window(w) => w.request_inner_size(size))
     }
 
     #[inline]

src/platform_impl/linux/wayland/window/mod.rs

@@ -292,13 +292,14 @@ impl Window {
     }
 
     #[inline]
-    pub fn set_inner_size(&self, size: Size) {
-        // TODO should we issue the resize event? I don't think other platforms do so.
+    pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
         let mut window_state = self.window_state.lock().unwrap();
         let scale_factor = window_state.scale_factor();
         window_state.resize(size.to_logical::<u32>(scale_factor));
 
         self.request_redraw();
+
+        Some(window_state.inner_size().to_physical(scale_factor))
     }
 
     /// Set the minimum inner size for the window.

src/platform_impl/linux/x11/event_processor.rs

@@ -419,7 +419,7 @@ impl<T: 'static> EventProcessor<T> {
                             });
 
                             if new_inner_size != old_inner_size {
-                                window.set_inner_size_physical(
+                                window.request_inner_size_physical(
                                     new_inner_size.width,
                                     new_inner_size.height,
                                 );
@@ -443,7 +443,7 @@ impl<T: 'static> EventProcessor<T> {
                             // When this finally happens, the event will not be synthetic.
                             shared_state_lock.dpi_adjusted = None;
                         } else {
-                            window.set_inner_size_physical(adjusted_size.0, adjusted_size.1);
+                            window.request_inner_size_physical(adjusted_size.0, adjusted_size.1);
                         }
                     }
 
@@ -1232,8 +1232,9 @@ impl<T: 'static> EventProcessor<T> {
 
                                             if new_inner_size != old_inner_size {
                                                 let (new_width, new_height) = new_inner_size.into();
-                                                window
-                                                    .set_inner_size_physical(new_width, new_height);
+                                                window.request_inner_size_physical(
+                                                    new_width, new_height,
+                                                );
                                             }
                                         }
                                     }

src/platform_impl/linux/x11/window.rs

@@ -1143,7 +1143,7 @@ impl UnownedWindow {
         }
     }
 
-    pub(crate) fn set_inner_size_physical(&self, width: u32, height: u32) {
+    pub(crate) fn request_inner_size_physical(&self, width: u32, height: u32) {
         unsafe {
             (self.xconn.xlib.XResizeWindow)(
                 self.xconn.display,
@@ -1157,7 +1157,7 @@ impl UnownedWindow {
     }
 
     #[inline]
-    pub fn set_inner_size(&self, size: Size) {
+    pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
         let scale_factor = self.scale_factor();
         let size = size.to_physical::<u32>(scale_factor).into();
         if !self.shared_state_lock().is_resizable {
@@ -1167,7 +1167,9 @@ impl UnownedWindow {
             })
             .expect("Failed to call `XSetWMNormalHints`");
         }
-        self.set_inner_size_physical(size.0, size.1);
+        self.request_inner_size_physical(size.0, size.1);
+
+        None
     }
 
     fn update_normal_hints<F>(&self, callback: F) -> Result<(), XError>

src/platform_impl/macos/window.rs

@@ -608,9 +608,10 @@ impl WinitWindow {
     }
 
     #[inline]
-    pub fn set_inner_size(&self, size: Size) {
+    pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
         let scale_factor = self.scale_factor();
         util::set_content_size_sync(self, size.to_logical(scale_factor));
+        None
     }
 
     pub fn set_min_inner_size(&self, dimensions: Option<Size>) {

src/platform_impl/orbital/window.rs

@@ -209,11 +209,12 @@ impl Window {
     }
 
     #[inline]
-    pub fn set_inner_size(&self, size: Size) {
+    pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
         let (w, h): (u32, u32) = size.to_physical::<u32>(self.scale_factor()).into();
         self.window_socket
             .write(format!("S,{w},{h}").as_bytes())
             .expect("failed to set size");
+        None
     }
 
     #[inline]

src/platform_impl/web/window.rs

@@ -148,12 +148,14 @@ impl Window {
     }
 
     #[inline]
-    pub fn set_inner_size(&self, size: Size) {
+    pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
         self.inner.dispatch(move |inner| {
             let size = size.to_logical(inner.scale_factor());
             let canvas = inner.canvas.borrow();
             backend::set_canvas_size(canvas.window(), canvas.raw(), size);
         });
+
+        None
     }
 
     #[inline]

src/platform_impl/windows/window.rs

@@ -210,7 +210,7 @@ impl Window {
     }
 
     #[inline]
-    pub fn set_inner_size(&self, size: Size) {
+    pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
         let scale_factor = self.scale_factor();
         let physical_size = size.to_physical::<u32>(scale_factor);
 
@@ -225,6 +225,7 @@ impl Window {
 
         let window_flags = self.window_state_lock().window_flags;
         window_flags.set_size(self.hwnd(), physical_size);
+        None
     }
 
     #[inline]
@@ -232,7 +233,7 @@ impl Window {
         self.window_state_lock().min_size = size;
         // Make windows re-check the window size bounds.
         let size = self.inner_size();
-        self.set_inner_size(size.into());
+        self.request_inner_size(size.into());
     }
 
     #[inline]
@@ -240,7 +241,7 @@ impl Window {
         self.window_state_lock().max_size = size;
         // Make windows re-check the window size bounds.
         let size = self.inner_size();
-        self.set_inner_size(size.into());
+        self.request_inner_size(size.into());
     }
 
     #[inline]
@@ -1051,11 +1052,11 @@ impl<'a, T: 'static> InitData<'a, T> {
                 .min_inner_size
                 .unwrap_or_else(|| PhysicalSize::new(0, 0).into());
             let clamped_size = Size::clamp(size, min_size, max_size, win.scale_factor());
-            win.set_inner_size(clamped_size);
+            win.request_inner_size(clamped_size);
 
             if attributes.maximized {
                 // Need to set MAXIMIZED after setting `inner_size` as
-                // `Window::set_inner_size` changes MAXIMIZED to false.
+                // `Window::request_inner_size` changes MAXIMIZED to false.
                 win.set_maximized(true);
             }
         }