Update wgpu to trunk (#34607)

* Update wgpu

8f82992b9f
Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>

* fix warnings

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>

* Update expectations

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>

* re

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>

* re

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>

* Allow git source for gfx-rs

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>

---------

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>

Cargo.lock

@@ -4365,9 +4365,9 @@ dependencies = [
 
 [[package]]
 name = "metal"
-version = "0.29.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ecfd3296f8c56b7c1f6fbac3c71cefa9d78ce009850c45000015f206dc7fa21"
+checksum = "9c3572083504c43e14aec05447f8a3d57cce0f66d7a3c1b9058572eca4d70ab9"
 dependencies = [
  "bitflags 2.6.0",
  "block",
@@ -4512,8 +4512,7 @@ checksum = "956787520e75e9bd233246045d19f42fb73242759cc57fba9611d940ae96d4b0"
 [[package]]
 name = "naga"
 version = "23.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+source = "git+https://github.com/gfx-rs/wgpu?rev=8f82992b9fa0fd71c19a4f5c2d8e2512ef22c010#8f82992b9fa0fd71c19a4f5c2d8e2512ef22c010"
-checksum = "3d5941e45a15b53aad4375eedf02033adb7a28931eedc31117faffa52e6a857e"
 dependencies = [
  "arrayvec",
  "bit-set",
@@ -8339,8 +8338,7 @@ checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"
 [[package]]
 name = "wgpu-core"
 version = "23.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+source = "git+https://github.com/gfx-rs/wgpu?rev=8f82992b9fa0fd71c19a4f5c2d8e2512ef22c010#8f82992b9fa0fd71c19a4f5c2d8e2512ef22c010"
-checksum = "d63c3c478de8e7e01786479919c8769f62a22eec16788d8c2ac77ce2c132778a"
 dependencies = [
  "arrayvec",
  "bit-vec",
@@ -8365,8 +8363,7 @@ dependencies = [
 [[package]]
 name = "wgpu-hal"
 version = "23.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+source = "git+https://github.com/gfx-rs/wgpu?rev=8f82992b9fa0fd71c19a4f5c2d8e2512ef22c010#8f82992b9fa0fd71c19a4f5c2d8e2512ef22c010"
-checksum = "89364b8a0b211adc7b16aeaf1bd5ad4a919c1154b44c9ce27838213ba05fd821"
 dependencies = [
  "android_system_properties",
  "arrayvec",
@@ -8377,7 +8374,7 @@ dependencies = [
  "bytemuck",
  "cfg_aliases 0.1.1",
  "core-graphics-types",
- "glow 0.14.2",
+ "glow 0.16.0",
  "glutin_wgl_sys",
  "gpu-alloc",
  "gpu-allocator",
@@ -8387,7 +8384,7 @@ dependencies = [
  "libc",
  "libloading",
  "log",
- "metal 0.29.0",
+ "metal 0.30.0",
  "naga",
  "ndk-sys 0.5.0+25.2.9519653",
  "objc",
@@ -8409,8 +8406,7 @@ dependencies = [
 [[package]]
 name = "wgpu-types"
 version = "23.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+source = "git+https://github.com/gfx-rs/wgpu?rev=8f82992b9fa0fd71c19a4f5c2d8e2512ef22c010#8f82992b9fa0fd71c19a4f5c2d8e2512ef22c010"
-checksum = "610f6ff27778148c31093f3b03abc4840f9636d58d597ca2f5977433acfe0068"
 dependencies = [
  "bitflags 2.6.0",
  "js-sys",

Cargo.toml

@@ -155,8 +155,8 @@ webrender_api = { git = "https://github.com/servo/webrender", branch = "0.65" }
 webrender_traits = { path = "components/shared/webrender" }
 webxr = { git = "https://github.com/servo/webxr" }
 webxr-api = { git = "https://github.com/servo/webxr" }
-wgpu-core = "23"
+wgpu-core = { git = "https://github.com/gfx-rs/wgpu", rev = "8f82992b9fa0fd71c19a4f5c2d8e2512ef22c010" }
-wgpu-types = "23"
+wgpu-types = { git = "https://github.com/gfx-rs/wgpu", rev = "8f82992b9fa0fd71c19a4f5c2d8e2512ef22c010" }
 windows-sys = "0.59"
 wr_malloc_size_of = { git = "https://github.com/servo/webrender", branch = "0.65" }
 xi-unicode = "0.3.0"

components/script/dom/webgpu/gpucommandencoder.rs

@@ -176,7 +176,8 @@ impl GPUCommandEncoderMethods<crate::DomTypeHolder> for GPUCommandEncoder {
             .colorAttachments
             .iter()
             .map(|color| -> Fallible<_> {
-                let channel = wgpu_com::PassChannel {
+                Ok(Some(wgpu_com::RenderPassColorAttachment {
+                    resolve_target: color.resolveTarget.as_ref().map(|t| t.id().0),
                     load_op: convert_load_op(Some(color.loadOp)),
                     store_op: convert_store_op(Some(color.storeOp)),
                     clear_value: color
@@ -185,11 +186,6 @@ impl GPUCommandEncoderMethods<crate::DomTypeHolder> for GPUCommandEncoder {
                         .map(|color| (color).try_convert())
                         .transpose()?
                         .unwrap_or_default(),
-                    read_only: false,
-                };
-                Ok(Some(wgpu_com::RenderPassColorAttachment {
-                    resolve_target: color.resolveTarget.as_ref().map(|t| t.id().0),
-                    channel,
                     view: color.view.id().0,
                 }))
             })

components/script/dom/webgpu/gpuconvert.rs

@@ -239,9 +239,9 @@ impl TryConvert<wgt::Extent3d> for &GPUExtent3D {
     }
 }
 
-impl Convert<wgt::ImageDataLayout> for &GPUImageDataLayout {
+impl Convert<wgt::TexelCopyBufferLayout> for &GPUImageDataLayout {
-    fn convert(self) -> wgt::ImageDataLayout {
+    fn convert(self) -> wgt::TexelCopyBufferLayout {
-        wgt::ImageDataLayout {
+        wgt::TexelCopyBufferLayout {
             offset: self.offset as wgt::BufferAddress,
             bytes_per_row: self.bytesPerRow,
             rows_per_image: self.rowsPerImage,
@@ -437,9 +437,9 @@ impl Convert<wgt::StencilOperation> for GPUStencilOperation {
     }
 }
 
-impl Convert<wgpu_com::ImageCopyBuffer> for &GPUImageCopyBuffer {
+impl Convert<wgpu_com::TexelCopyBufferInfo> for &GPUImageCopyBuffer {
-    fn convert(self) -> wgpu_com::ImageCopyBuffer {
+    fn convert(self) -> wgpu_com::TexelCopyBufferInfo {
-        wgpu_com::ImageCopyBuffer {
+        wgpu_com::TexelCopyBufferInfo {
             buffer: self.buffer.id().0,
             layout: self.parent.convert(),
         }
@@ -474,11 +474,11 @@ impl TryConvert<wgt::Origin3d> for &GPUOrigin3D {
     }
 }
 
-impl TryConvert<wgpu_com::ImageCopyTexture> for &GPUImageCopyTexture {
+impl TryConvert<wgpu_com::TexelCopyTextureInfo> for &GPUImageCopyTexture {
     type Error = Error;
 
-    fn try_convert(self) -> Result<wgpu_com::ImageCopyTexture, Self::Error> {
+    fn try_convert(self) -> Result<wgpu_com::TexelCopyTextureInfo, Self::Error> {
-        Ok(wgpu_com::ImageCopyTexture {
+        Ok(wgpu_com::TexelCopyTextureInfo {
             texture: self.texture.id().0,
             mip_level: self.mipLevel,
             origin: self

components/webgpu/ipc_messages/recv.rs

@@ -15,7 +15,7 @@ use wgc::binding_model::{
     BindGroupDescriptor, BindGroupLayoutDescriptor, PipelineLayoutDescriptor,
 };
 use wgc::command::{
-    ImageCopyBuffer, ImageCopyTexture, RenderBundleDescriptor, RenderBundleEncoder,
+    RenderBundleDescriptor, RenderBundleEncoder, TexelCopyBufferInfo, TexelCopyTextureInfo,
 };
 use wgc::device::HostMap;
 use wgc::id;
@@ -69,20 +69,20 @@ pub enum WebGPURequest {
     },
     CopyBufferToTexture {
         command_encoder_id: id::CommandEncoderId,
-        source: ImageCopyBuffer,
+        source: TexelCopyBufferInfo,
-        destination: ImageCopyTexture,
+        destination: TexelCopyTextureInfo,
         copy_size: wgt::Extent3d,
     },
     CopyTextureToBuffer {
         command_encoder_id: id::CommandEncoderId,
-        source: ImageCopyTexture,
+        source: TexelCopyTextureInfo,
-        destination: ImageCopyBuffer,
+        destination: TexelCopyBufferInfo,
         copy_size: wgt::Extent3d,
     },
     CopyTextureToTexture {
         command_encoder_id: id::CommandEncoderId,
-        source: ImageCopyTexture,
+        source: TexelCopyTextureInfo,
-        destination: ImageCopyTexture,
+        destination: TexelCopyTextureInfo,
         copy_size: wgt::Extent3d,
     },
     CreateBindGroup {
@@ -291,8 +291,8 @@ pub enum WebGPURequest {
     WriteTexture {
         device_id: id::DeviceId,
         queue_id: id::QueueId,
-        texture_cv: ImageCopyTexture,
+        texture_cv: TexelCopyTextureInfo,
-        data_layout: wgt::ImageDataLayout,
+        data_layout: wgt::TexelCopyBufferLayout,
         size: wgt::Extent3d,
         data: IpcSharedMemory,
     },

components/webgpu/swapchain.rs

@@ -23,7 +23,7 @@ use webrender_traits::{WebrenderExternalImageApi, WebrenderImageSource};
 use wgpu_core::device::HostMap;
 use wgpu_core::global::Global;
 use wgpu_core::id;
-use wgpu_core::resource::{BufferAccessError, BufferMapCallback, BufferMapOperation};
+use wgpu_core::resource::{BufferAccessError, BufferMapOperation};
 
 use crate::{wgt, ContextConfiguration, Error, WebGPUMsg};
 
@@ -471,15 +471,15 @@ impl crate::WGPU {
         let (encoder_id, error) =
             global.device_create_command_encoder(device_id, &comm_desc, Some(encoder_id));
         err(error)?;
-        let buffer_cv = wgt::ImageCopyBuffer {
+        let buffer_cv = wgt::TexelCopyBufferInfo {
             buffer: buffer_id,
-            layout: wgt::ImageDataLayout {
+            layout: wgt::TexelCopyBufferLayout {
                 offset: 0,
                 bytes_per_row: Some(image_desc.buffer_stride() as u32),
                 rows_per_image: None,
             },
         };
-        let texture_cv = wgt::ImageCopyTexture {
+        let texture_cv = wgt::TexelCopyTextureInfo {
             texture: texture_id,
             mip_level: 0,
             origin: wgt::Origin3d::ZERO,
@@ -511,7 +511,7 @@ impl crate::WGPU {
             let webrender_api = Arc::clone(&self.webrender_api);
             let webrender_document = self.webrender_document;
             let token = self.poller.token();
-            BufferMapCallback::from_rust(Box::from(move |result| {
+            Box::new(move |result| {
                 drop(token);
                 update_wr_image(
                     result,
@@ -524,7 +524,7 @@ impl crate::WGPU {
                     image_desc,
                     presentation_id,
                 );
-            }))
+            })
         };
         let map_op = BufferMapOperation {
             host: HostMap::Read,

components/webgpu/wgpu_thread.rs

@@ -17,13 +17,12 @@ use webrender::{RenderApi, RenderApiSender};
 use webrender_api::{DocumentId, ExternalImageId};
 use webrender_traits::{WebrenderExternalImageRegistry, WebrenderImageHandlerType};
 use wgc::command::{ComputePass, ComputePassDescriptor, RenderPass};
-use wgc::device::queue::SubmittedWorkDoneClosure;
+use wgc::device::{DeviceDescriptor, ImplicitPipelineIds};
-use wgc::device::{DeviceDescriptor, DeviceLostClosure, ImplicitPipelineIds};
 use wgc::id;
 use wgc::id::DeviceId;
 use wgc::instance::parse_backends_from_comma_list;
 use wgc::pipeline::ShaderModuleDescriptor;
-use wgc::resource::{BufferMapCallback, BufferMapOperation};
+use wgc::resource::BufferMapOperation;
 use wgpu_core::command::RenderPassDescriptor;
 use wgpu_core::device::DeviceError;
 use wgpu_core::pipeline::{CreateComputePipelineError, CreateRenderPipelineError};
@@ -178,34 +177,32 @@ impl WGPU {
                         let glob = Arc::clone(&self.global);
                         let resp_sender = sender.clone();
                         let token = self.poller.token();
-                        let callback = BufferMapCallback::from_rust(Box::from(
+                        let callback = Box::from(move |result: BufferAccessResult| {
-                            move |result: BufferAccessResult| {
+                            drop(token);
-                                drop(token);
+                            let response = result.and_then(|_| {
-                                let response = result.and_then(|_| {
+                                let global = &glob;
-                                    let global = &glob;
+                                let (slice_pointer, range_size) =
-                                    let (slice_pointer, range_size) =
+                                    global.buffer_get_mapped_range(buffer_id, offset, size)?;
-                                        global.buffer_get_mapped_range(buffer_id, offset, size)?;
+                                // SAFETY: guarantee to be safe from wgpu
-                                    // SAFETY: guarantee to be safe from wgpu
+                                let data = unsafe {
-                                    let data = unsafe {
+                                    slice::from_raw_parts(
-                                        slice::from_raw_parts(
+                                        slice_pointer.as_ptr(),
-                                            slice_pointer.as_ptr(),
+                                        range_size as usize,
-                                            range_size as usize,
+                                    )
-                                        )
+                                };
-                                    };
 
-                                    Ok(Mapping {
+                                Ok(Mapping {
-                                        data: IpcSharedMemory::from_bytes(data),
+                                    data: IpcSharedMemory::from_bytes(data),
-                                        range: offset..offset + range_size,
+                                    range: offset..offset + range_size,
-                                        mode: host_map,
+                                    mode: host_map,
-                                    })
+                                })
-                                });
+                            });
-                                if let Err(e) =
+                            if let Err(e) =
-                                    resp_sender.send(WebGPUResponse::BufferMapAsync(response))
+                                resp_sender.send(WebGPUResponse::BufferMapAsync(response))
-                                {
+                            {
-                                    warn!("Could not send BufferMapAsync Response ({})", e);
+                                warn!("Could not send BufferMapAsync Response ({})", e);
-                                }
+                            }
-                            },
+                        });
-                        ));
 
                         let operation = BufferMapOperation {
                             host: host_map,
@@ -711,40 +708,32 @@ impl WGPU {
                                 }
                                 let script_sender = self.script_sender.clone();
                                 let devices = Arc::clone(&self.devices);
-                                let callback =
+                                let callback = Box::from(move |reason, msg| {
-                                    DeviceLostClosure::from_rust(Box::from(move |reason, msg| {
+                                    let reason = match reason {
-                                        let reason = match reason {
+                                        wgt::DeviceLostReason::Unknown => {
-                                            wgt::DeviceLostReason::Unknown => {
+                                            crate::DeviceLostReason::Unknown
-                                                crate::DeviceLostReason::Unknown
+                                        },
-                                            },
+                                        wgt::DeviceLostReason::Destroyed => {
-                                            wgt::DeviceLostReason::Destroyed => {
+                                            crate::DeviceLostReason::Destroyed
-                                                crate::DeviceLostReason::Destroyed
+                                        },
-                                            },
+                                    };
-                                            // we handle this in WebGPUMsg::FreeDevice
+                                    // make device lost by removing error scopes stack
-                                            wgt::DeviceLostReason::Dropped => return,
+                                    let _ = devices
-                                            wgt::DeviceLostReason::ReplacedCallback => {
+                                        .lock()
-                                                panic!(
+                                        .unwrap()
-                                                    "DeviceLost callback should only be set once"
+                                        .get_mut(&device_id)
-                                                )
+                                        .expect("Device should not be dropped by this point")
-                                            },
+                                        .error_scope_stack
-                                        };
+                                        .take();
-                                        // make device lost by removing error scopes stack
+                                    if let Err(e) = script_sender.send(WebGPUMsg::DeviceLost {
-                                        let _ = devices
+                                        device,
-                                            .lock()
+                                        pipeline_id,
-                                            .unwrap()
+                                        reason,
-                                            .get_mut(&device_id)
+                                        msg,
-                                            .expect("Device should not be dropped by this point")
+                                    }) {
-                                            .error_scope_stack
+                                        warn!("Failed to send WebGPUMsg::DeviceLost: {e}");
-                                            .take();
+                                    }
-                                        if let Err(e) = script_sender.send(WebGPUMsg::DeviceLost {
+                                });
-                                            device,
-                                            pipeline_id,
-                                            reason,
-                                            msg,
-                                        }) {
-                                            warn!("Failed to send WebGPUMsg::DeviceLost: {e}");
-                                        }
-                                    }));
                                 global.device_set_device_lost_closure(device_id, callback);
                                 descriptor
                             });
@@ -1055,12 +1044,12 @@ impl WGPU {
                     WebGPURequest::QueueOnSubmittedWorkDone { sender, queue_id } => {
                         let global = &self.global;
                         let token = self.poller.token();
-                        let callback = SubmittedWorkDoneClosure::from_rust(Box::from(move || {
+                        let callback = Box::from(move || {
                             drop(token);
                             if let Err(e) = sender.send(WebGPUResponse::SubmittedWorkDone) {
                                 warn!("Could not send SubmittedWorkDone Response ({})", e);
                             }
-                        }));
+                        });
                         global.queue_on_submitted_work_done(queue_id, callback);
                         self.poller.wake();
                     },

deny.toml

@@ -154,4 +154,4 @@ skip = [
 
 # github.com organizations to allow git sources for
 [sources.allow-org]
-github = ["pcwalton", "servo"]
+github = ["pcwalton", "servo", "gfx-rs"]