Revert "GPUQueue.writeBuffer takes offset/size in elements with TypedArrays"

This reverts commit 480f5952.

Reason for revert: Wrong revision of patch landed.

Original change's description:
> GPUQueue.writeBuffer takes offset/size in elements with TypedArrays
>
> Previously dataOffset and size were always in bytes, which isn't
> consistent with the WebGPU spec.
>
> Corresponding CTS test here: https://github.com/gpuweb/cts/pull/431
>
> Bug: 1163667
> Change-Id: I5360cfbd66542c044dcf909b8673d3ed3f5e6724
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2615520
> Reviewed-by: Corentin Wallez <cwallez@chromium.org>
> Commit-Queue: Brandon Jones <bajones@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#841617}

TBR=bajones@chromium.org,cwallez@chromium.org,kainino@chromium.org,chromium-scoped@luci-project-accounts.iam.gserviceaccount.com

Change-Id: I385bb20542bb12e609d40087a2458e8775499438
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 1163667
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2618376Reviewed-by: Brandon Jones <bajones@chromium.org>
Commit-Queue: Brandon Jones <bajones@chromium.org>
Cr-Commit-Position: refs/heads/master@{#841659}

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

@@ -178,22 +178,22 @@ GPUFence* GPUQueue::createFence(const GPUFenceDescriptor* descriptor) {
 void GPUQueue::writeBuffer(GPUBuffer* buffer,
                            uint64_t buffer_offset,
                            const MaybeShared<DOMArrayBufferView>& data,
-                           uint64_t data_element_offset,
+                           uint64_t data_byte_offset,
                            ExceptionState& exception_state) {
   WriteBufferImpl(buffer, buffer_offset, data->byteLength(),
                   data->BaseAddressMaybeShared(), data->TypeSize(),
-                  data_element_offset, {}, exception_state);
+                  data_byte_offset, {}, exception_state);
 }
 
 void GPUQueue::writeBuffer(GPUBuffer* buffer,
                            uint64_t buffer_offset,
                            const MaybeShared<DOMArrayBufferView>& data,
-                           uint64_t data_element_offset,
-                           uint64_t data_element_count,
+                           uint64_t data_byte_offset,
+                           uint64_t byte_size,
                            ExceptionState& exception_state) {
   WriteBufferImpl(buffer, buffer_offset, data->byteLength(),
                   data->BaseAddressMaybeShared(), data->TypeSize(),
-                  data_element_offset, data_element_count, exception_state);
+                  data_byte_offset, byte_size, exception_state);
 }
 
 void GPUQueue::writeBuffer(GPUBuffer* buffer,
@@ -222,38 +222,41 @@ void GPUQueue::WriteBufferImpl(GPUBuffer* buffer,
                                uint64_t data_byte_length,
                                const void* data_base_ptr,
                                unsigned data_bytes_per_element,
-                               uint64_t data_element_offset,
-                               base::Optional<uint64_t> data_element_count,
+                               uint64_t data_byte_offset,
+                               base::Optional<uint64_t> byte_size,
                                ExceptionState& exception_state) {
   if (buffer_offset % 4 != 0) {
     exception_state.ThrowDOMException(DOMExceptionCode::kOperationError,
-                                      "Buffer offset must be a multiple of 4");
+                                      "bufferOffset must be a multiple of 4");
     return;
   }
 
-  uint64_t data_byte_offset = data_element_offset * data_bytes_per_element;
+  if (data_byte_offset % data_bytes_per_element != 0) {
+    exception_state.ThrowDOMException(
+        DOMExceptionCode::kOperationError,
+        "dataByteOffset must be a multiple of data.BYTES_PER_ELEMENT");
+    return;
+  }
 
   if (data_byte_offset > data_byte_length) {
     exception_state.ThrowDOMException(DOMExceptionCode::kOperationError,
-                                      "Data offset is too large");
+                                      "dataByteOffset is too large");
     return;
   }
   uint64_t max_write_size = data_byte_length - data_byte_offset;
 
   uint64_t write_byte_size = max_write_size;
-  if (data_element_count.has_value()) {
-    write_byte_size = data_element_count.value() * data_bytes_per_element;
+  if (byte_size.has_value()) {
+    write_byte_size = byte_size.value();
     if (write_byte_size > max_write_size) {
-      exception_state.ThrowDOMException(
-          DOMExceptionCode::kOperationError,
-          "Number of bytes to write is too large");
+      exception_state.ThrowDOMException(DOMExceptionCode::kOperationError,
+                                        "byteSize is too large");
       return;
     }
   }
-  if (write_byte_size % 4 != 0) {
-    exception_state.ThrowDOMException(
-        DOMExceptionCode::kOperationError,
-        "Number of bytes to write must be a multiple of 4");
+  if (write_byte_size % std::max(4u, data_bytes_per_element) != 0) {
+    exception_state.ThrowRangeError(
+        "byteSize must be a multiple of max(4, data.BYTES_PER_ELEMENT)");
     return;
   }
 

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

@@ -37,13 +37,13 @@ class GPUQueue : public DawnObject<WGPUQueue> {
   void writeBuffer(GPUBuffer* buffer,
                    uint64_t buffer_offset,
                    const MaybeShared<DOMArrayBufferView>& data,
-                   uint64_t data_element_offset,
+                   uint64_t data_byte_offset,
                    ExceptionState& exception_state);
   void writeBuffer(GPUBuffer* buffer,
                    uint64_t buffer_offset,
                    const MaybeShared<DOMArrayBufferView>& data,
-                   uint64_t data_element_offset,
-                   uint64_t data_element_count,
+                   uint64_t data_byte_offset,
+                   uint64_t byte_size,
                    ExceptionState& exception_state);
   void writeBuffer(GPUBuffer* buffer,
                    uint64_t buffer_offset,

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

@@ -19,8 +19,8 @@
         GPUBuffer buffer,
         GPUSize64 bufferOffset,
         [AllowShared] ArrayBufferView data,
-        optional GPUSize64 dataElementOffset = 0,
-        optional GPUSize64 dataElementCount);
+        optional GPUSize64 dataByteOffset = 0,
+        optional GPUSize64 byteSize);
     [RaisesException] void writeBuffer(
         GPUBuffer buffer,
         GPUSize64 bufferOffset,