[deno_webgpu] Support additional copyBufferToBuffer signatures

Author: andyleiserson

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: Option<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)]