Use raw-window-metal to do Metal layer creation

This uses observers internally, which fixes resizing when using Wgpu
together with an auto-layout NSView.

Though it probably won't matter much, it's also more reliable to update
the scale factor this way, rather than haphazardly in `configure`.

Cargo.toml

@@ -138,6 +138,7 @@ block = "0.1"
 core-graphics-types = "0.1"
 metal = { version = "0.29.0" }
 objc = "0.2.5"
+raw-window-metal = "1.0"
 
 # Vulkan dependencies
 android_system_properties = "0.1.1"

wgpu-hal/Cargo.toml

@@ -44,6 +44,7 @@ metal = [
     # Metal is only available on Apple platforms, therefore request MSL output also only if we target an Apple platform.
     "naga/msl-out-if-target-apple",
     "dep:block",
+    "dep:raw-window-metal",
 ]
 vulkan = [
     "naga/spv-out",
@@ -53,6 +54,7 @@ vulkan = [
     "dep:libloading",
     "dep:smallvec",
     "dep:android_system_properties",
+    "dep:raw-window-metal",
 ]
 gles = [
     "naga/glsl-out",
@@ -166,6 +168,9 @@ glutin_wgl_sys = { workspace = true, optional = true }
 # backend: Metal
 block = { workspace = true, optional = true }
 
+# backend: Metal + Vulkan
+raw-window-metal = { workspace = true, optional = true }
+
 metal.workspace = true
 objc.workspace = true
 core-graphics-types.workspace = true

wgpu-hal/src/metal/mod.rs

@@ -34,7 +34,7 @@ use std::{
 
 use arrayvec::ArrayVec;
 use bitflags::bitflags;
-use metal::foreign_types::ForeignTypeRef as _;
+use metal::foreign_types::{ForeignType as _, ForeignTypeRef as _};
 use parking_lot::{Mutex, RwLock};
 
 #[derive(Clone, Debug)]
@@ -100,7 +100,7 @@ pub struct Instance {}
 
 impl Instance {
     pub fn create_surface_from_layer(&self, layer: &metal::MetalLayerRef) -> Surface {
-        unsafe { Surface::from_layer(layer) }
+        Surface::from_layer(layer)
     }
 }
 
@@ -119,19 +119,25 @@ impl crate::Instance for Instance {
         _display_handle: raw_window_handle::RawDisplayHandle,
         window_handle: raw_window_handle::RawWindowHandle,
     ) -> Result<Surface, crate::InstanceError> {
-        match window_handle {
-            #[cfg(target_os = "ios")]
-            raw_window_handle::RawWindowHandle::UiKit(handle) => {
-                Ok(unsafe { Surface::from_view(handle.ui_view.cast()) })
+        let layer = match window_handle {
+            raw_window_handle::RawWindowHandle::AppKit(handle) => unsafe {
+                raw_window_metal::Layer::from_ns_view(handle.ns_view)
+            },
+            raw_window_handle::RawWindowHandle::UiKit(handle) => unsafe {
+                raw_window_metal::Layer::from_ui_view(handle.ui_view)
+            },
+            _ => {
+                return Err(crate::InstanceError::new(format!(
+                    "window handle {window_handle:?} is not a Metal-compatible handle"
+                )))
             }
-            #[cfg(target_os = "macos")]
-            raw_window_handle::RawWindowHandle::AppKit(handle) => {
-                Ok(unsafe { Surface::from_view(handle.ns_view.cast()) })
-            }
-            _ => Err(crate::InstanceError::new(format!(
-                "window handle {window_handle:?} is not a Metal-compatible handle"
-            ))),
-        }
+        };
+
+        // SAFETY: The layer is an initialized instance of `CAMetalLayer`, and
+        // we transfer the retain count to `MetalLayer` using `into_raw`.
+        let layer = unsafe { metal::MetalLayer::from_ptr(layer.into_raw().cast().as_ptr()) };
+
+        Ok(Surface::new(layer))
     }
 
     unsafe fn enumerate_adapters(