Commit ecec971c authored by Corentin Wallez's avatar Corentin Wallez Committed by Commit Bot

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: default avatarAustin Eng <enga@chromium.org>
Reviewed-by: default avatarKai Ninomiya <kainino@chromium.org>
Cr-Commit-Position: refs/heads/master@{#799762}
parent 38512bce
......@@ -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());
......
......@@ -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);
......
......@@ -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();
};
......@@ -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);
......
......@@ -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);
......
......@@ -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 = {});
......
......@@ -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();
});
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment