WebGPU: Remove deprecated buffer mapping code paths

Following the PSA for API deprecations, the following are removed:

 - GPUDevice.createBufferMapped
 - GPUBuffer.mapReadAsync
 - GPUBuffer.mapWriteAsync

Also a small check in ValidateRange is fixed.

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

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

@@ -38,8 +38,7 @@ bool ValidateRangeCreation(ExceptionState& exception_state,
                            uint64_t mapping_size,
                            size_t max_size) {
   if (mapping_size > uint64_t(max_size) ||
-      mapping_offset >
-          uint64_t(std::numeric_limits<size_t>::max()) - mapping_size) {
+      mapping_offset > uint64_t(max_size) - mapping_size) {
     exception_state.ThrowRangeError(
         WTF::String::Format("%s offset (%" PRIu64 " bytes) and size (%" PRIu64
                             " bytes) are too large for this implementation.",
@@ -91,35 +90,6 @@ GPUBuffer* GPUBuffer::Create(GPUDevice* device,
       device->GetProcs().deviceCreateBuffer(device->GetHandle(), &dawn_desc));
 }
 
-// static
-std::pair<GPUBuffer*, DOMArrayBuffer*> GPUBuffer::CreateMapped(
-    GPUDevice* device,
-    const GPUBufferDescriptor* webgpu_desc,
-    ExceptionState& exception_state) {
-  DCHECK(device);
-
-  std::string label;
-  WGPUBufferDescriptor dawn_desc = AsDawnType(webgpu_desc, &label);
-
-  if (!ValidateRangeCreation(exception_state, "createBufferMapped", 0,
-                             dawn_desc.size, kLargestMappableSize)) {
-    return std::make_pair(nullptr, nullptr);
-  }
-
-  WGPUCreateBufferMappedResult result =
-      device->GetProcs().deviceCreateBufferMapped(device->GetHandle(),
-                                                  &dawn_desc);
-
-  GPUBuffer* gpu_buffer = MakeGarbageCollected<GPUBuffer>(
-      device, dawn_desc.size, true, result.buffer);
-
-  DOMArrayBuffer* mapped_array_buffer =
-      gpu_buffer->CreateArrayBufferForMappedData(
-          result.data, static_cast<size_t>(result.dataLength));
-
-  return std::make_pair(gpu_buffer, mapped_array_buffer);
-}
-
 GPUBuffer::GPUBuffer(GPUDevice* device,
                      uint64_t size,
                      bool mapped_at_creation,
@@ -143,37 +113,6 @@ void GPUBuffer::Trace(Visitor* visitor) const {
   DawnObject<WGPUBuffer>::Trace(visitor);
 }
 
-void GPUBuffer::OnOldMapAsyncCallback(ScriptPromiseResolver* resolver,
-                                      WGPUBufferMapAsyncStatus status,
-                                      void* data,
-                                      uint64_t data_length) {
-  switch (status) {
-    case WGPUBufferMapAsyncStatus_Success: {
-      DCHECK(data);
-      DCHECK_LE(data_length, kLargestMappableSize);
-
-      map_start_ = 0;
-      map_end_ = data_length;
-      mapped_ranges_.push_back(
-          std::make_pair(0, static_cast<size_t>(data_length)));
-      DOMArrayBuffer* mapped_buffer = CreateArrayBufferForMappedData(
-          data, static_cast<size_t>(data_length));
-      resolver->Resolve(mapped_buffer);
-    } break;
-    case WGPUBufferMapAsyncStatus_Error:
-    case WGPUBufferMapAsyncStatus_Unknown:
-    case WGPUBufferMapAsyncStatus_DeviceLost:
-      resolver->Reject(MakeGarbageCollected<DOMException>(
-          DOMExceptionCode::kOperationError));
-      break;
-    default:
-      NOTREACHED();
-      resolver->Reject(
-          MakeGarbageCollected<DOMException>(DOMExceptionCode::kAbortError));
-      break;
-  }
-}
-
 ScriptPromise GPUBuffer::mapAsync(ScriptState* script_state,
                                   uint32_t mode,
                                   uint64_t offset,
@@ -201,73 +140,6 @@ DOMArrayBuffer* GPUBuffer::getMappedRange(uint64_t offset,
   return GetMappedRangeImpl(offset, size, exception_state);
 }
 
-ScriptPromise GPUBuffer::mapReadAsync(ScriptState* script_state,
-                                      ExceptionState& exception_state) {
-  device_->AddConsoleWarning(
-      "mapReadAsync is deprecated: use mapAsync+getMappedRange instead");
-
-  ScriptPromiseResolver* resolver =
-      MakeGarbageCollected<ScriptPromiseResolver>(script_state);
-  ScriptPromise promise = resolver->Promise();
-
-  if (!ValidateRangeCreation(exception_state, "mapReadAsync", 0, size_,
-                             kLargestMappableSize)) {
-    resolver->Reject(exception_state);
-    return promise;
-  }
-
-  auto* callback =
-      BindDawnCallback(&GPUBuffer::OnOldMapAsyncCallback, WrapPersistent(this),
-                       WrapPersistent(resolver));
-
-  using Callback = std::remove_reference_t<decltype(*callback)>;
-
-  GetProcs().bufferMapReadAsync(
-      GetHandle(),
-      [](WGPUBufferMapAsyncStatus status, const void* data,
-         uint64_t data_length, void* userdata) {
-        // It is safe to const_cast the |data| pointer because it is a shadow
-        // copy that Dawn wire makes and does not point to the mapped GPU data.
-        // Dawn wire's copy of the data is not used outside of tests.
-        return Callback::CallUnboundCallback(status, const_cast<void*>(data),
-                                             data_length, userdata);
-      },
-      callback->AsUserdata());
-  // WebGPU guarantees callbacks complete in finite time. Flush now so that
-  // commands reach the GPU process.
-  device_->GetInterface()->FlushCommands();
-
-  return promise;
-}
-
-ScriptPromise GPUBuffer::mapWriteAsync(ScriptState* script_state,
-                                       ExceptionState& exception_state) {
-  device_->AddConsoleWarning(
-      "mapWriteAsync is deprecated: use mapAsync+getMappedRange instead");
-
-  ScriptPromiseResolver* resolver =
-      MakeGarbageCollected<ScriptPromiseResolver>(script_state);
-  ScriptPromise promise = resolver->Promise();
-
-  if (!ValidateRangeCreation(exception_state, "mapWriteAsync", 0, size_,
-                             kLargestMappableSize)) {
-    resolver->Reject(exception_state);
-    return promise;
-  }
-
-  auto* callback =
-      BindDawnCallback(&GPUBuffer::OnOldMapAsyncCallback, WrapPersistent(this),
-                       WrapPersistent(resolver));
-
-  GetProcs().bufferMapWriteAsync(GetHandle(), callback->UnboundCallback(),
-                                 callback->AsUserdata());
-  // WebGPU guarantees callbacks complete in finite time. Flush now so that
-  // commands reach the GPU process.
-  device_->GetInterface()->FlushCommands();
-
-  return promise;
-}
-
 void GPUBuffer::unmap(ScriptState* script_state) {
   ResetMappingState(script_state);
   GetProcs().bufferUnmap(GetHandle());

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

@@ -24,10 +24,6 @@ class GPUBuffer : public DawnObject<WGPUBuffer> {
  public:
   static GPUBuffer* Create(GPUDevice* device,
                            const GPUBufferDescriptor* webgpu_desc);
-  static std::pair<GPUBuffer*, DOMArrayBuffer*> CreateMapped(
-      GPUDevice* device,
-      const GPUBufferDescriptor* webgpu_desc,
-      ExceptionState& exception_state);
   explicit GPUBuffer(GPUDevice* device,
                      uint64_t size,
                      bool mapped_at_creation,
@@ -51,10 +47,6 @@ class GPUBuffer : public DawnObject<WGPUBuffer> {
   DOMArrayBuffer* getMappedRange(uint64_t offset,
                                  uint64_t size,
                                  ExceptionState& exception_state);
-  ScriptPromise mapReadAsync(ScriptState* script_state,
-                             ExceptionState& exception_state);
-  ScriptPromise mapWriteAsync(ScriptState* script_state,
-                              ExceptionState& exception_state);
   void unmap(ScriptState* script_state);
   void destroy(ScriptState* script_state);
   // TODO(crbug.com/877147): implement GPUBuffer.
@@ -73,10 +65,6 @@ class GPUBuffer : public DawnObject<WGPUBuffer> {
                           uint64_t map_start,
                           uint64_t map_end,
                           WGPUBufferMapAsyncStatus status);
-  void OnOldMapAsyncCallback(ScriptPromiseResolver* resolver,
-                             WGPUBufferMapAsyncStatus status,
-                             void* data,
-                             uint64_t data_length);
 
   DOMArrayBuffer* CreateArrayBufferForMappedData(void* data,
                                                  size_t data_length);

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

@@ -13,9 +13,6 @@
         optional GPUSize64 size);
     [RaisesException] ArrayBuffer getMappedRange(optional GPUSize64 offset = 0,
                                                  optional GPUSize64 size);
-    // TODO(crbug.com/1069302): Remove these deprecated entry points.
-    [CallWith=ScriptState, RaisesException] Promise<ArrayBuffer> mapReadAsync();
-    [CallWith=ScriptState, RaisesException] Promise<ArrayBuffer> mapWriteAsync();
     [CallWith=ScriptState] void unmap();
     [CallWith=ScriptState] void destroy();
 };

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

@@ -159,21 +159,6 @@ GPUBuffer* GPUDevice::createBuffer(const GPUBufferDescriptor* descriptor) {
   return GPUBuffer::Create(this, descriptor);
 }
 
-HeapVector<GPUBufferOrArrayBuffer> GPUDevice::createBufferMapped(
-    const GPUBufferDescriptor* descriptor,
-    ExceptionState& exception_state) {
-  AddConsoleWarning(
-      "createBufferMapped is deprecated: use mappedAtCreation instead");
-
-  GPUBuffer* gpu_buffer;
-  DOMArrayBuffer* array_buffer;
-  std::tie(gpu_buffer, array_buffer) =
-      GPUBuffer::CreateMapped(this, descriptor, exception_state);
-  return HeapVector<GPUBufferOrArrayBuffer>(
-      {GPUBufferOrArrayBuffer::FromGPUBuffer(gpu_buffer),
-       GPUBufferOrArrayBuffer::FromArrayBuffer(array_buffer)});
-}
-
 GPUTexture* GPUDevice::createTexture(const GPUTextureDescriptor* descriptor,
                                      ExceptionState& exception_state) {
   return GPUTexture::Create(this, descriptor, exception_state);

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

@@ -70,9 +70,6 @@ class GPUDevice final : public EventTargetWithInlineData,
   GPUQueue* defaultQueue();
 
   GPUBuffer* createBuffer(const GPUBufferDescriptor* descriptor);
-  HeapVector<GPUBufferOrArrayBuffer> createBufferMapped(
-      const GPUBufferDescriptor* descriptor,
-      ExceptionState& exception_state);
   GPUTexture* createTexture(const GPUTextureDescriptor* descriptor,
                             ExceptionState& exception_state);
   GPUSampler* createSampler(const GPUSamplerDescriptor* descriptor);

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

@@ -14,8 +14,6 @@
     [SameObject] readonly attribute GPUQueue defaultQueue;
 
     GPUBuffer createBuffer(GPUBufferDescriptor descriptor);
-    // TODO(crbug.com/1069302): Remove this deprecated entry point.
-    [RaisesException] GPUMappedBuffer createBufferMapped(GPUBufferDescriptor descriptor);
     [RaisesException] GPUTexture createTexture(GPUTextureDescriptor descriptor);
     GPUSampler createSampler(optional GPUSamplerDescriptor descriptor = {});
 

third_party/blink/web_tests/regress/regress-1104580.html

@@ -21,13 +21,15 @@ async_test((test) => {
       test.done();
       return;
     }
-    device.createBufferMapped({
+    device.createBuffer({
               size: 24,
-              usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST
+              usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+              mappedAtCreation: true
           });
-    device.createBufferMapped({
+    device.createBuffer({
               size: 0,
-              usage: GPUBufferUsage.VERTEX | 2261634.5098
+              usage: GPUBufferUsage.VERTEX | 2261634.5098,
+              mappedAtCreation: true
           });
     test.done();
   });