WebGPU: implement GPUQueue.writeBuffer

Bug: 1069302
Change-Id: Iea10257e35bd11e724241dbc038955cc8a0b47a8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2222299
Commit-Queue: Kai Ninomiya <kainino@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Austin Eng <enga@chromium.org>
Cr-Commit-Position: refs/heads/master@{#773844}

third_party/blink/renderer/modules/webgpu/gpu_buffer.cc

@@ -132,9 +132,8 @@ void GPUBuffer::setSubData(uint64_t dst_byte_offset,
                            uint64_t byte_length,
                            ExceptionState& exception_state) {
   device_->AddConsoleWarning(
-      "GPUBuffer.setSubData is deprecated: use createBufferMapped "
-      "(with copyBufferToBuffer if needed) "
-      "(but note the design/spec of this API is still in flux)");
+      "GPUBuffer.setSubData is deprecated: use GPUQueue.writeBuffer instead");
+
   const uint8_t* src_base =
       reinterpret_cast<const uint8_t*>(src.BaseAddressMaybeOnStack());
   size_t src_byte_length = src.ByteLengthAsSizeT();

third_party/blink/renderer/modules/webgpu/gpu_queue.cc

@@ -16,8 +16,10 @@
 #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_image_bitmap_copy_view.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_texture_copy_view.h"
 #include "third_party/blink/renderer/core/imagebitmap/image_bitmap.h"
+#include "third_party/blink/renderer/core/typed_arrays/dom_array_buffer.h"
 #include "third_party/blink/renderer/modules/webgpu/client_validation.h"
 #include "third_party/blink/renderer/modules/webgpu/dawn_conversions.h"
+#include "third_party/blink/renderer/modules/webgpu/gpu_buffer.h"
 #include "third_party/blink/renderer/modules/webgpu/gpu_command_buffer.h"
 #include "third_party/blink/renderer/modules/webgpu/gpu_device.h"
 #include "third_party/blink/renderer/modules/webgpu/gpu_fence.h"
@@ -151,6 +153,64 @@ GPUFence* GPUQueue::createFence(const GPUFenceDescriptor* descriptor) {
       device_, GetProcs().queueCreateFence(GetHandle(), &desc));
 }
 
+void GPUQueue::writeBuffer(GPUBuffer* buffer,
+                           uint64_t bufferOffset,
+                           const DOMArrayBuffer* data,
+                           uint64_t dataOffset,
+                           ExceptionState& exception_state) {
+  WriteBufferImpl(buffer, bufferOffset, data, dataOffset, {}, exception_state);
+}
+
+void GPUQueue::writeBuffer(GPUBuffer* buffer,
+                           uint64_t bufferOffset,
+                           const DOMArrayBuffer* data,
+                           uint64_t dataOffset,
+                           uint64_t size,
+                           ExceptionState& exception_state) {
+  WriteBufferImpl(buffer, bufferOffset, data, dataOffset, size,
+                  exception_state);
+}
+
+void GPUQueue::WriteBufferImpl(GPUBuffer* buffer,
+                               uint64_t buffer_offset,
+                               const DOMArrayBuffer* data,
+                               uint64_t data_offset,
+                               base::Optional<uint64_t> size,
+                               ExceptionState& exception_state) {
+  if (buffer_offset % 4 != 0) {
+    exception_state.ThrowDOMException(DOMExceptionCode::kOperationError,
+                                      "bufferOffset must be a multiple of 4");
+    return;
+  }
+
+  size_t data_byte_length = data->ByteLengthAsSizeT();
+  if (data_offset > data_byte_length) {
+    exception_state.ThrowRangeError("dataOffset is too large");
+    return;
+  }
+
+  uint64_t max_write_size = data_byte_length - data_offset;
+  uint64_t write_size = max_write_size;
+  if (size.has_value()) {
+    write_size = size.value();
+    if (write_size > max_write_size) {
+      exception_state.ThrowRangeError("size is too large");
+      return;
+    }
+  }
+  if (write_size % 4 != 0) {
+    exception_state.ThrowRangeError("size must be a multiple of 4");
+    return;
+  }
+
+  const uint8_t* data_base =
+      static_cast<const uint8_t*>(data->DataMaybeShared());
+
+  const uint8_t* data_at_offset = &data_base[data_offset];
+  GetProcs().bufferSetSubData(buffer->GetHandle(), buffer_offset, write_size,
+                              data_at_offset);
+}
+
 // TODO(shaobo.yan@intel.com): Implement this function
 void GPUQueue::copyImageBitmapToTexture(
     GPUImageBitmapCopyView* source,

third_party/blink/renderer/modules/webgpu/gpu_queue.h

@@ -12,7 +12,9 @@ namespace blink {
 
 class CanvasColorParams;
 class DawnTextureFromImageBitmap;
+class DOMArrayBuffer;
 class ExceptionState;
+class GPUBuffer;
 class GPUCommandBuffer;
 class GPUFence;
 class GPUFenceDescriptor;
@@ -32,6 +34,23 @@ class GPUQueue : public DawnObject<WGPUQueue> {
   void submit(const HeapVector<Member<GPUCommandBuffer>>& buffers);
   void signal(GPUFence* fence, uint64_t signal_value);
   GPUFence* createFence(const GPUFenceDescriptor* descriptor);
+  void writeBuffer(GPUBuffer* buffer,
+                   uint64_t bufferOffset,
+                   const DOMArrayBuffer* data,
+                   uint64_t dataOffset,
+                   ExceptionState& exception_state);
+  void writeBuffer(GPUBuffer* buffer,
+                   uint64_t bufferOffset,
+                   const DOMArrayBuffer* data,
+                   uint64_t dataOffset,
+                   uint64_t size,
+                   ExceptionState& exception_state);
+  void WriteBufferImpl(GPUBuffer* buffer,
+                       uint64_t buffer_offset,
+                       const DOMArrayBuffer* data,
+                       uint64_t data_offset,
+                       base::Optional<uint64_t> size,
+                       ExceptionState& exception_state);
   void copyImageBitmapToTexture(
       GPUImageBitmapCopyView* source,
       GPUTextureCopyView* destination,

third_party/blink/renderer/modules/webgpu/gpu_queue.idl

@@ -11,6 +11,17 @@
 
     GPUFence createFence(optional GPUFenceDescriptor descriptor = {});
     void signal(GPUFence fence, GPUFenceValue signalValue);
+
+    // TODO(crbug.com/1088107): |data| should be [AllowShared] ArrayBuffer,
+    // or maybe [AllowShared] ArrayBufferView
+    // (https://github.com/gpuweb/gpuweb/issues/820)
+    [RaisesException] void writeBuffer(
+        GPUBuffer buffer,
+        GPUSize64 bufferOffset,
+        ArrayBuffer data,
+        optional GPUSize64 dataOffset = 0,
+        optional GPUSize64 size);
+
     [RaisesException] void copyImageBitmapToTexture(
         GPUImageBitmapCopyView source,
         GPUTextureCopyView destination,