chore(deps): switch to objc2-metal crate

Author: wravery

Cargo.toml

@@ -41,12 +41,11 @@ glib-unix = "0.22"
 io-surface = "0.16"
 libc = "0.2"
 libloading = "0.9"
-metal = "0.33"
-objc = "0.2"
 objc2 = "0.6.3"
 objc2-app-kit = { version = "0.3.2", default-features = false }
 objc2-foundation = "0.3.2"
 objc2-io-surface = "0.3.2"
+objc2-metal = { version = "0.3", features = ["objc2-io-surface"] }
 plist = "1"
 proc-macro2 = "1"
 quote = "1"
@@ -58,7 +57,7 @@ syn = { version = "2", features = ["full"] }
 thiserror = "2"
 toml_edit = "0.25"
 tracing = "0.1"
-wgpu = "28"
+wgpu = "29"
 winres = "0.1"
 x11-dl = "2"
 

cef/Cargo.toml

@@ -22,9 +22,9 @@ sandbox = ["cef-dll-sys/sandbox"]
 accelerated_osr = [
     "ash",
     "libc",
-    "objc",
+    "objc2-foundation",
     "objc2-io-surface",
-    "metal",
+    "objc2-metal",
     "thiserror",
     "tracing",
     "wgpu",
@@ -72,9 +72,9 @@ windows = { workspace = true, optional = true }
 [target.'cfg(target_os = "macos")'.dependencies]
 libloading.workspace = true
 objc2.workspace = true
+objc2-foundation = { workspace = true, optional = true }
 objc2-io-surface = { workspace = true, optional = true }
-objc = { workspace = true, optional = true }
-metal = { workspace = true, optional = true }
+objc2-metal = { workspace = true, optional = true }
 plist = { workspace = true, optional = true }
 semver = { workspace = true, optional = true }
 

cef/src/osr_texture_import/iosurface.rs

@@ -1,19 +1,19 @@
 //! macOS IOSurface texture import implementation
 
-#![allow(unexpected_cfgs)] // Suppress objc crate internal cfg warnings
-
 use super::common::texture;
 use super::{TextureImportError, TextureImportResult, TextureImporter};
 use crate::osr_texture_import::common::format;
 use crate::{sys::cef_color_type_t, AcceleratedPaintInfo};
+use objc2::rc::Retained;
 use objc2_io_surface::IOSurfaceRef;
+use objc2_metal::{
+    MTLDevice, MTLPixelFormat, MTLStorageMode, MTLTextureDescriptor, MTLTextureType,
+    MTLTextureUsage,
+};
 use wgpu::TextureDescriptor;
 
 use std::os::raw::c_void;
 
-#[cfg(target_os = "macos")]
-use objc::{sel, sel_impl};
-
 pub struct IOSurfaceImporter {
     pub handle: *mut c_void,
     pub format: cef_color_type_t,
@@ -91,43 +91,41 @@ impl IOSurfaceImporter {
     fn get_metal_desc(
         &self,
         texture_desc: &TextureDescriptor,
-    ) -> Result<metal::TextureDescriptor, TextureImportError> {
-        use metal::{MTLPixelFormat, MTLStorageMode, MTLTextureType, MTLTextureUsage};
-
+    ) -> Result<Retained<MTLTextureDescriptor>, TextureImportError> {
         if self.width == 0 || self.height == 0 {
             return Err(TextureImportError::InvalidHandle(
                 "Invalid IOSurface texture dimensions".to_string(),
             ));
         }
 
-        let metal_desc = metal::TextureDescriptor::new();
-        metal_desc.set_width(texture_desc.size.width as _);
-        metal_desc.set_height(texture_desc.size.height as _);
-        metal_desc.set_array_length(texture_desc.array_layer_count() as _);
-        metal_desc.set_mipmap_level_count(texture_desc.mip_level_count as _);
-        metal_desc.set_sample_count(texture_desc.sample_count as _);
-        metal_desc.set_texture_type(MTLTextureType::D2);
-        metal_desc.set_pixel_format(match texture_desc.format {
-            wgpu::TextureFormat::Rgba8Unorm => MTLPixelFormat::RGBA8Unorm,
-            wgpu::TextureFormat::Bgra8Unorm => MTLPixelFormat::BGRA8Unorm,
-            _ => unimplemented!(),
-        });
-        metal_desc.set_usage(MTLTextureUsage::ShaderRead);
-        metal_desc.set_storage_mode(MTLStorageMode::Managed);
+        let metal_desc = MTLTextureDescriptor::new();
+        unsafe {
+            metal_desc.setWidth(texture_desc.size.width as _);
+            metal_desc.setHeight(texture_desc.size.height as _);
+            metal_desc.setArrayLength(texture_desc.array_layer_count() as _);
+            metal_desc.setMipmapLevelCount(texture_desc.mip_level_count as _);
+            metal_desc.setSampleCount(texture_desc.sample_count as _);
+            metal_desc.setTextureType(MTLTextureType::Type2D);
+            metal_desc.setPixelFormat(match texture_desc.format {
+                wgpu::TextureFormat::Rgba8Unorm => MTLPixelFormat::RGBA8Unorm,
+                wgpu::TextureFormat::Bgra8Unorm => MTLPixelFormat::BGRA8Unorm,
+                _ => unimplemented!(),
+            });
+            metal_desc.setUsage(MTLTextureUsage::ShaderRead);
+            metal_desc.setStorageMode(MTLStorageMode::Managed);
+        }
 
         Ok(metal_desc)
     }
 
     fn import_via_metal(&self, device: &wgpu::Device) -> TextureImportResult {
-        use metal::MTLTextureType;
-
         // Convert handle to IOSurface
         let io_surface = std::ptr::NonNull::new(self.handle.cast::<IOSurfaceRef>()).ok_or(
             TextureImportError::InvalidHandle("Invalid IOSurface handle".to_string()),
         )?;
 
         let texture_desc = self.get_texture_desc();
-        let hal_tex = objc::rc::autoreleasepool(|| {
+        let hal_tex = {
             let metal_desc = self.get_metal_desc(&texture_desc)?;
 
             // Get Metal device from wgpu and create texture
@@ -139,17 +137,21 @@ impl IOSurfaceImporter {
                     ));
                 };
 
-                let texture = objc::msg_send![
-                    hal_device.raw_device().as_ref(),
-                    newTextureWithDescriptor:metal_desc.as_ref()
-                    iosurface:io_surface
-                    plane:0
-                ];
+                let texture = hal_device
+                    .raw_device()
+                    .newTextureWithDescriptor_iosurface_plane(
+                        metal_desc.as_ref(),
+                        io_surface.as_ref(),
+                        0,
+                    )
+                    .ok_or(TextureImportError::InvalidHandle(
+                        "Invalid IOSurface handle".to_string(),
+                    ))?;
 
                 let hal_tex = <wgpu::wgc::api::Metal as wgpu::hal::Api>::Device::texture_from_raw(
                     texture,
                     texture_desc.format,
-                    MTLTextureType::D2,
+                    MTLTextureType::Type2D,
                     texture_desc.array_layer_count(),
                     texture_desc.mip_level_count,
                     wgpu::hal::CopyExtent {
@@ -161,8 +163,8 @@ impl IOSurfaceImporter {
 
                 Ok::<_, TextureImportError>(hal_tex)
             }?;
-            Ok(texture)
-        })?;
+            texture
+        };
 
         Ok(unsafe {
             device.create_texture_from_hal::<wgpu::wgc::api::Metal>(hal_tex, &texture_desc)

examples/osr/Cargo.toml

@@ -26,9 +26,8 @@ windows = { workspace = true }
 libloading.workspace = true
 
 [target.'cfg(target_os = "macos")'.dependencies]
-metal.workspace = true
-objc.workspace = true
-io-surface.workspace = true
+objc2-metal.workspace = true
+objc2-io-surface.workspace = true
 
 [target.'cfg(target_os = "linux")'.dependencies]
 libc.workspace = true

examples/osr/src/main.rs

@@ -2,8 +2,7 @@ mod webrender;
 
 use cef::{args::Args, *};
 use std::{cell::RefCell, process::ExitCode, sync::Arc, thread::sleep, time::Duration};
-use wgpu::Backends;
-use wgpu::util::DeviceExt;
+use wgpu::{Backends, CurrentSurfaceTexture, util::DeviceExt};
 use winit::{
     application::ApplicationHandler,
     event::WindowEvent,
@@ -30,15 +29,15 @@ struct State {
 
 impl State {
     async fn new(window: Arc<Window>) -> State {
-        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
             #[cfg(target_os = "windows")]
             backends: Backends::from_comma_list("dx12"),
             #[cfg(target_os = "macos")]
             backends: Backends::from_comma_list("metal"),
             #[cfg(target_os = "linux")]
             backends: Backends::from_comma_list("vulkan"),
             //flags: wgpu::InstanceFlags::debugging(),
-            ..Default::default()
+            ..wgpu::InstanceDescriptor::new_without_display_handle()
         });
         let adapter = instance
             .request_adapter(&wgpu::RequestAdapterOptions {
@@ -91,7 +90,7 @@ impl State {
         let render_pipeline_layout =
             device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
                 label: Some("Cef Pipeline Layout"),
-                bind_group_layouts: &[&texture_bind_group_layout],
+                bind_group_layouts: &[Some(&texture_bind_group_layout)],
                 immediate_size: 0,
             });
         let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
@@ -178,10 +177,15 @@ impl State {
     }
 
     fn render(&mut self) {
-        let surface_texture = self
-            .surface
-            .get_current_texture()
-            .expect("failed to acquire next swapchain texture");
+        let surface_texture = match self.surface.get_current_texture() {
+            CurrentSurfaceTexture::Success(success) => success,
+            CurrentSurfaceTexture::Suboptimal(suboptimal) => {
+                self.configure_surface();
+                suboptimal
+            }
+            _ => return,
+        };
+
         let frame = surface_texture
             .texture
             .create_view(&wgpu::TextureViewDescriptor {

examples/tests_shared/src/browser/client_app_browser.rs

@@ -9,7 +9,7 @@ use std::{
     sync::Arc,
 };
 
-pub trait Delegate: Send {
+pub trait Delegate: Send + Sync {
     fn on_before_command_line_processing(
         &self,
         _app: &Arc<ClientAppBrowser>,