Bump raw window handle to 0.6.0

Cargo.toml

@@ -85,7 +85,7 @@ pico-args = { version = "0.5.0", features = ["eq-separator", "short-space-opt",
 png = "0.17.10"
 pollster = "0.3"
 profiling = { version = "1", default-features = false }
-raw-window-handle = "0.5"
+raw-window-handle = "0.6"
 renderdoc-sys = "1.0.0"
 ron = "0.8"
 serde = "1"

wgpu-core/Cargo.toml

@@ -63,7 +63,7 @@ log = "0.4"
 # parking_lot 0.12 switches from `winapi` to `windows`; permit either
 parking_lot = ">=0.11,<0.13"
 profiling = { version = "1", default-features = false }
-raw-window-handle = { version = "0.5", optional = true }
+raw-window-handle = { version = "0.6", optional = true }
 ron = { version = "0.8", optional = true }
 serde = { version = "1", features = ["serde_derive"], optional = true }
 smallvec = "1"

wgpu-hal/Cargo.toml

@@ -57,7 +57,7 @@ required-features = ["gles"]
 bitflags = "2"
 parking_lot = ">=0.11,<0.13"
 profiling = { version = "1", default-features = false }
-raw-window-handle = "0.5"
+raw-window-handle = "0.6"
 thiserror = "1"
 
 # backends common

wgpu-hal/src/gles/egl.rs

@@ -922,7 +922,7 @@ impl crate::Instance<super::Api> for Instance {
             (Rwh::Wayland(_), raw_window_handle::RawDisplayHandle::Wayland(display_handle)) => {
                 if inner
                     .wl_display
-                    .map(|ptr| ptr != display_handle.display)
+                    .map(|ptr| ptr != display_handle.display.as_ptr())
                     .unwrap_or(true)
                 {
                     /* Wayland displays are not sharable between surfaces so if the
@@ -943,7 +943,7 @@ impl crate::Instance<super::Api> for Instance {
                         .unwrap()
                         .get_platform_display(
                             EGL_PLATFORM_WAYLAND_KHR,
-                            display_handle.display,
+                            display_handle.display.as_ptr(),
                             &display_attributes,
                         )
                         .unwrap();
@@ -956,7 +956,7 @@ impl crate::Instance<super::Api> for Instance {
                     )?;
 
                     let old_inner = std::mem::replace(inner.deref_mut(), new_inner);
-                    inner.wl_display = Some(display_handle.display);
+                    inner.wl_display = Some(display_handle.display.as_ptr());
 
                     drop(old_inner);
                 }
@@ -1196,24 +1196,24 @@ impl crate::Surface<super::Api> for Surface {
                         &mut temp_xcb_handle as *mut _ as *mut std::ffi::c_void
                     }
                     (WindowKind::AngleX11, Rwh::Xcb(handle)) => {
-                        handle.window as *mut std::ffi::c_void
+                        handle.window.get() as *mut std::ffi::c_void
                     }
-                    (WindowKind::Unknown, Rwh::AndroidNdk(handle)) => handle.a_native_window,
+                    (WindowKind::Unknown, Rwh::AndroidNdk(handle)) => handle.a_native_window.as_ptr(),
                     (WindowKind::Wayland, Rwh::Wayland(handle)) => {
                         let library = &self.wsi.display_owner.as_ref().unwrap().library;
                         let wl_egl_window_create: libloading::Symbol<WlEglWindowCreateFun> =
                             unsafe { library.get(b"wl_egl_window_create") }.unwrap();
-                        let window = unsafe { wl_egl_window_create(handle.surface, 640, 480) }
+                        let window = unsafe { wl_egl_window_create(handle.surface.as_ptr(), 640, 480) }
                             as *mut _ as *mut std::ffi::c_void;
                         wl_window = Some(window);
                         window
                     }
                     #[cfg(target_os = "emscripten")]
                     (WindowKind::Unknown, Rwh::Web(handle)) => handle.id as *mut std::ffi::c_void,
-                    (WindowKind::Unknown, Rwh::Win32(handle)) => handle.hwnd,
+                    (WindowKind::Unknown, Rwh::Win32(handle)) => handle.hwnd.get() as * mut std::ffi::c_void,
                     (WindowKind::Unknown, Rwh::AppKit(handle)) => {
                         #[cfg(not(target_os = "macos"))]
-                        let window_ptr = handle.ns_view;
+                        let window_ptr = handle.ns_view.as_ptr();
                         #[cfg(target_os = "macos")]
                         let window_ptr = {
                             use objc::{msg_send, runtime::Object, sel, sel_impl};

wgpu-hal/src/vulkan/instance.rs

@@ -740,15 +740,17 @@ impl crate::Instance<super::Api> for super::Instance {
 
         match (window_handle, display_handle) {
             (Rwh::Wayland(handle), Rdh::Wayland(display)) => {
-                self.create_surface_from_wayland(display.display, handle.surface)
+                self.create_surface_from_wayland(display.display.as_ptr(), handle.surface.as_ptr())
             }
             (Rwh::Xlib(handle), Rdh::Xlib(display)) => {
-                self.create_surface_from_xlib(display.display as *mut _, handle.window)
+                let display = display.display.expect("Display pointer is not set.");
+                self.create_surface_from_xlib(display.as_ptr() as *mut *const c_void, handle.window)
             }
             (Rwh::Xcb(handle), Rdh::Xcb(display)) => {
-                self.create_surface_from_xcb(display.connection, handle.window)
+                let connection = display.connection.expect("Pointer to X-Server is not set.");
+                self.create_surface_from_xcb(connection.as_ptr(), handle.window.get())
             }
-            (Rwh::AndroidNdk(handle), _) => self.create_surface_android(handle.a_native_window),
+            (Rwh::AndroidNdk(handle), _) => self.create_surface_android(handle.a_native_window.as_ptr()),
             #[cfg(windows)]
             (Rwh::Win32(handle), _) => {
                 use winapi::um::libloaderapi::GetModuleHandleW;

wgpu/Cargo.toml

@@ -98,7 +98,7 @@ arrayvec.workspace = true
 log.workspace = true
 parking_lot.workspace = true
 profiling.workspace = true
-raw-window-handle.workspace = true
+raw-window-handle = { workspace = true, features = ["std"] }
 serde = { workspace = true, features = ["derive"], optional = true }
 smallvec.workspace = true
 static_assertions.workspace = true

wgpu/src/lib.rs

@@ -1937,15 +1937,27 @@ impl Instance {
     /// - On web: will panic if the `raw_window_handle` does not properly refer to a
     ///   canvas element.
     pub unsafe fn create_surface<
-        W: raw_window_handle::HasRawWindowHandle + raw_window_handle::HasRawDisplayHandle,
+        W: raw_window_handle::HasWindowHandle + raw_window_handle::HasDisplayHandle,
     >(
         &self,
         window: &W,
     ) -> Result<Surface, CreateSurfaceError> {
+        let raw_display_handle = window
+            .display_handle()
+            .map_err(|e| CreateSurfaceError {
+                inner: CreateSurfaceErrorKind::RawHandle(e)
+            })?
+            .as_raw();
+        let raw_window_handle = window
+            .window_handle()
+            .map_err(|e| CreateSurfaceError {
+                inner: CreateSurfaceErrorKind::RawHandle(e)
+            })?
+            .as_raw();
         let (id, data) = DynContext::instance_create_surface(
             &*self.context,
-            raw_window_handle::HasRawDisplayHandle::raw_display_handle(window),
-            raw_window_handle::HasRawWindowHandle::raw_window_handle(window),
+            raw_display_handle,
+            raw_window_handle
         )?;
         Ok(Surface {
             context: Arc::clone(&self.context),
@@ -2900,6 +2912,10 @@ enum CreateSurfaceErrorKind {
     /// Error from WebGPU surface creation.
     #[allow(dead_code)] // may be unused depending on target and features
     Web(String),
+
+    /// Error when trying to get a [`DisplayHandle`] or a [`WindowHandle`] from
+    /// `raw_window_handle`.
+    RawHandle(raw_window_handle::HandleError),
 }
 static_assertions::assert_impl_all!(CreateSurfaceError: Send, Sync);
 
@@ -2913,6 +2929,7 @@ impl fmt::Display for CreateSurfaceError {
             ))]
             CreateSurfaceErrorKind::Hal(e) => e.fmt(f),
             CreateSurfaceErrorKind::Web(e) => e.fmt(f),
+            CreateSurfaceErrorKind::RawHandle(e) => e.fmt(f),
         }
     }
 }
@@ -2927,6 +2944,7 @@ impl error::Error for CreateSurfaceError {
             ))]
             CreateSurfaceErrorKind::Hal(e) => e.source(),
             CreateSurfaceErrorKind::Web(_) => None,
+            CreateSurfaceErrorKind::RawHandle(e) => e.source(),
         }
     }
 }