Make the copy_buffer_to_buffer size parameter optional (#7659)

* Make wgpu-core's copy_buffer_to_buffer `size` parameter optional

* Make the copy size optional in more places

* Fix for webgpu backend

* [deno_webgpu] Support additional copyBufferToBuffer signatures

* Add changelog entry

* Add copyBufferToBuffer tests to CTS test list

(This doesn't actually enable the tests for the new overloads, because
of a different error reporting issue that affects many CTS tests
including these. But if you run the tests for the new overloads
manually, before and after the fix, you can see that the behavior has
changed.)

* Reproducible formula for vendoring modified webgpu-sys

Commit the updated vendor command in all the files for consistency.

Author: andyleiserson

CHANGELOG.md

@@ -102,6 +102,10 @@ Naga now infers the correct binding layout when a resource appears only in an as
 
 - Use highest SPIR-V version supported by Vulkan API version. By @robamler in [#7595](https://github.com/gfx-rs/wgpu/pull/7595)
 
+#### WebGPU
+
+- The type of the `size` parameter to `copy_buffer_to_buffer` has changed from `BufferAddress` to `impl Into<Option<BufferAddress>>`. This achieves the spec-defined behavior of the value being optional, while still accepting existing calls without changes. By @andyleiserson in [#7659](https://github.com/gfx-rs/wgpu/pull/7659).
+
 ### Bug Fixes
 
 #### Naga

cts_runner/test.lst

@@ -1,5 +1,10 @@
 unittests:*
 webgpu:api,operation,command_buffer,basic:*
+webgpu:api,operation,command_buffer,copyBufferToBuffer:single:newSig=false;*
+// https://github.com/gfx-rs/wgpu/issues/7391
+//FAIL: webgpu:api,operation,command_buffer,copyBufferToBuffer:single:newSig=true;*
+webgpu:api,operation,command_buffer,copyBufferToBuffer:state_transitions:*
+webgpu:api,operation,command_buffer,copyBufferToBuffer:copy_order:*
 webgpu:api,operation,compute,basic:memcpy:*
 //FAIL: webgpu:api,operation,compute,basic:large_dispatch:*
 webgpu:api,operation,device,lost:*

deno_webgpu/command_encoder.rs

@@ -5,11 +5,13 @@ use std::cell::RefCell;
 
 use deno_core::cppgc::Ptr;
 use deno_core::op2;
+use deno_core::v8;
+use deno_core::webidl::{IntOptions, WebIdlConverter, WebIdlError};
 use deno_core::GarbageCollected;
 use deno_core::WebIDL;
 use deno_error::JsErrorBox;
 use wgpu_core::command::PassChannel;
-use wgpu_types::TexelCopyBufferInfo;
+use wgpu_types::{BufferAddress, TexelCopyBufferInfo};
 
 use crate::buffer::GPUBuffer;
 use crate::command_buffer::GPUCommandBuffer;
@@ -171,15 +173,78 @@ impl GPUCommandEncoder {
         }
     }
 
-    #[required(5)]
-    fn copy_buffer_to_buffer(
+    #[required(2)]
+    fn copy_buffer_to_buffer<'a>(
         &self,
+        scope: &mut v8::HandleScope<'a>,
         #[webidl] source: Ptr<GPUBuffer>,
-        #[webidl(options(enforce_range = true))] source_offset: u64,
-        #[webidl] destination: Ptr<GPUBuffer>,
-        #[webidl(options(enforce_range = true))] destination_offset: u64,
-        #[webidl(options(enforce_range = true))] size: u64,
-    ) {
+        arg2: v8::Local<'a, v8::Value>,
+        arg3: v8::Local<'a, v8::Value>,
+        arg4: v8::Local<'a, v8::Value>,
+        arg5: v8::Local<'a, v8::Value>,
+    ) -> Result<(), WebIdlError> {
+        let prefix = "Failed to execute 'GPUCommandEncoder.copyBufferToBuffer'";
+        let int_options = IntOptions {
+            clamp: false,
+            enforce_range: true,
+        };
+
+        let source_offset: BufferAddress;
+        let destination: Ptr<GPUBuffer>;
+        let destination_offset: BufferAddress;
+        let size: Option<BufferAddress>;
+        // Note that the last argument to either overload of `copy_buffer_to_buffer`
+        // is optional, so `arg5.is_undefined()` would not work here.
+        if arg4.is_undefined() {
+            // 3-argument overload
+            source_offset = 0;
+            destination = Ptr::<GPUBuffer>::convert(
+                scope,
+                arg2,
+                Cow::Borrowed(prefix),
+                (|| Cow::Borrowed("destination")).into(),
+                &(),
+            )?;
+            destination_offset = 0;
+            size = <Option<u64>>::convert(
+                scope,
+                arg3,
+                Cow::Borrowed(prefix),
+                (|| Cow::Borrowed("size")).into(),
+                &int_options,
+            )?;
+        } else {
+            // 5-argument overload
+            source_offset = u64::convert(
+                scope,
+                arg2,
+                Cow::Borrowed(prefix),
+                (|| Cow::Borrowed("sourceOffset")).into(),
+                &int_options,
+            )?;
+            destination = Ptr::<GPUBuffer>::convert(
+                scope,
+                arg3,
+                Cow::Borrowed(prefix),
+                (|| Cow::Borrowed("destination")).into(),
+                &(),
+            )?;
+            destination_offset = u64::convert(
+                scope,
+                arg4,
+                Cow::Borrowed(prefix),
+                (|| Cow::Borrowed("destinationOffset")).into(),
+                &int_options,
+            )?;
+            size = <Option<u64>>::convert(
+                scope,
+                arg5,
+                Cow::Borrowed(prefix),
+                (|| Cow::Borrowed("size")).into(),
+                &int_options,
+            )?;
+        }
+
         let err = self
             .instance
             .command_encoder_copy_buffer_to_buffer(
@@ -193,6 +258,8 @@ impl GPUCommandEncoder {
             .err();
 
         self.error_handler.push_error(err);
+
+        Ok(())
     }
 
     #[required(3)]

wgpu-core/src/command/transfer.rs

@@ -532,7 +532,7 @@ impl Global {
         source_offset: BufferAddress,
         destination: BufferId,
         destination_offset: BufferAddress,
-        size: BufferAddress,
+        size: Option<BufferAddress>,
     ) -> Result<(), CopyError> {
         profiling::scope!("CommandEncoder::copy_buffer_to_buffer");
         api_log!(
@@ -598,6 +598,11 @@ impl Global {
             .map_err(TransferError::MissingBufferUsage)?;
         let dst_barrier = dst_pending.map(|pending| pending.into_hal(&dst_buffer, &snatch_guard));
 
+        let (size, source_end_offset) = match size {
+            Some(size) => (size, source_offset + size),
+            None => (src_buffer.size - source_offset, src_buffer.size),
+        };
+
         if size % wgt::COPY_BUFFER_ALIGNMENT != 0 {
             return Err(TransferError::UnalignedCopySize(size).into());
         }
@@ -628,7 +633,6 @@ impl Global {
             }
         }
 
-        let source_end_offset = source_offset + size;
         let destination_end_offset = destination_offset + size;
         if source_end_offset > src_buffer.size {
             return Err(TransferError::BufferOverrun {

wgpu-core/src/device/trace.rs

@@ -151,7 +151,7 @@ pub enum Command {
         src_offset: wgt::BufferAddress,
         dst: id::BufferId,
         dst_offset: wgt::BufferAddress,
-        size: wgt::BufferAddress,
+        size: Option<wgt::BufferAddress>,
     },
     CopyBufferToTexture {
         src: crate::command::TexelCopyBufferInfo,

wgpu/src/api/command_encoder.rs

@@ -116,14 +116,14 @@ impl CommandEncoder {
         source_offset: BufferAddress,
         destination: &Buffer,
         destination_offset: BufferAddress,
-        copy_size: BufferAddress,
+        copy_size: impl Into<Option<BufferAddress>>,
     ) {
         self.inner.copy_buffer_to_buffer(
             &source.inner,
             source_offset,
             &destination.inner,
             destination_offset,
-            copy_size,
+            copy_size.into(),
         );
     }
 

wgpu/src/backend/webgpu.rs

@@ -2813,20 +2813,31 @@ impl dispatch::CommandEncoderInterface for WebCommandEncoder {
         source_offset: crate::BufferAddress,
         destination: &dispatch::DispatchBuffer,
         destination_offset: crate::BufferAddress,
-        copy_size: crate::BufferAddress,
+        copy_size: Option<crate::BufferAddress>,
     ) {
         let source = source.as_webgpu();
         let destination = destination.as_webgpu();
 
-        self.inner
-            .copy_buffer_to_buffer_with_f64_and_f64_and_f64(
-                &source.inner,
-                source_offset as f64,
-                &destination.inner,
-                destination_offset as f64,
-                copy_size as f64,
-            )
-            .unwrap();
+        if let Some(size) = copy_size {
+            self.inner
+                .copy_buffer_to_buffer_with_f64_and_f64_and_f64(
+                    &source.inner,
+                    source_offset as f64,
+                    &destination.inner,
+                    destination_offset as f64,
+                    size as f64,
+                )
+                .unwrap();
+        } else {
+            self.inner
+                .copy_buffer_to_buffer_with_f64_and_f64(
+                    &source.inner,
+                    source_offset as f64,
+                    &destination.inner,
+                    destination_offset as f64,
+                )
+                .unwrap();
+        }
     }
 
     fn copy_buffer_to_texture(