Revert "[dawn] Removes old non-overridden non-Future entry."
This reverts commit fa07f3046419775df4d2f8fb5b0a9c5078399d4e.
Reason for revert: Breaking Dawn->Chromium roll, need to update MLDrift.
Original change's description:
> [dawn] Removes old non-overridden non-Future entry.
>
> - Removes/Renames the following entry points and their
> corresponding old Callbacks and CallbackInfos:
> - ShaderModule::GetCompilationInfo
> - Device::Create*PipelineAsync
> - Device::PopErrorScope
> - Buffer::MapAsync
> - Queue::OnSubmittedWorkDone
> - Note that "overridden" entry points will be removed in
> multi-CL changes since those refer to entry points
> where users may be manually overriding the C proc table.
>
> Bug: 369445924
> Change-Id: I074cac71587b64555288e44c9f483d9426c7abd0
> Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/216314
> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
> Commit-Queue: Loko Kung <lokokung@google.com>
Bug: 369445924
Change-Id: Ia93ea22936c5a37ba9d86fb9a34d10b1c5ebcbff
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/220294
Commit-Queue: Loko Kung <lokokung@google.com>
Reviewed-by: Jiawei Shao <jiawei.shao@intel.com>
Reviewed-by: Loko Kung <lokokung@google.com>
Auto-Submit: Loko Kung <lokokung@google.com>
diff --git a/generator/templates/mock_api.cpp b/generator/templates/mock_api.cpp
index e976aef..dc5c9e1 100644
--- a/generator/templates/mock_api.cpp
+++ b/generator/templates/mock_api.cpp
@@ -98,7 +98,10 @@
object->m{{Suffix}}Userdata = userdata;
{% endfor %}
- {% if method.name.get() not in LegacyCallbackFunctions %}
+ {% if method.name.get() == 'pop error scope' %}
+ //* Currently special casing popErrorScope since it has an old callback type.
+ On{{Suffix}}({{-as_varName(type.name)}}, {.nextInChain = nullptr, .mode = WGPUCallbackMode_AllowProcessEvents, .callback = nullptr, .oldCallback = oldCallback, .userdata = userdata});
+ {% elif method.name.get() not in LegacyCallbackFunctions %}
On{{Suffix}}(
{{-as_varName(type.name)}}
{%- for arg in method.arguments if arg.type.category != 'function pointer' and arg.type.name.get() != 'void *' -%}
diff --git a/src/dawn/dawn.json b/src/dawn/dawn.json
index e4712d5..85cacb8 100644
--- a/src/dawn/dawn.json
+++ b/src/dawn/dawn.json
@@ -600,6 +600,18 @@
"methods": [
{
"name": "map async",
+ "args": [
+ {"name": "mode", "type": "map mode"},
+ {"name": "offset", "type": "size_t"},
+ {"name": "size", "type": "size_t"},
+ {"name": "callback", "type": "buffer map callback"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ {
+ "name": "map async f",
+ "_comment": "TODO(crbug.com/dawn/2021): This is dawn/emscripten-only until we rename it to replace the old API. See bug for details.",
+ "tags": ["dawn", "emscripten"],
"returns": "future",
"args": [
{"name": "mode", "type": "map mode"},
@@ -609,6 +621,18 @@
]
},
{
+ "name": "map async 2",
+ "_comment": "TODO(crbug.com/dawn/2021): This is dawn/emscripten-only until we rename it to replace the old API. See bug for details.",
+ "tags": ["dawn", "emscripten"],
+ "returns": "future",
+ "args": [
+ {"name": "mode", "type": "map mode"},
+ {"name": "offset", "type": "size_t"},
+ {"name": "size", "type": "size_t"},
+ {"name": "callback info", "type": "buffer map callback info 2"}
+ ]
+ },
+ {
"name": "get mapped range",
"returns": "void *",
"args": [
@@ -682,6 +706,13 @@
]
},
"buffer map callback": {
+ "category": "function pointer",
+ "args": [
+ {"name": "status", "type": "buffer map async status"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ "buffer map callback 2": {
"category": "callback function",
"args": [
{"name": "status", "type": "map async status"},
@@ -689,10 +720,35 @@
]
},
"buffer map callback info": {
+ "category": "structure",
+ "extensible": "in",
+ "members": [
+ {"name": "mode", "type": "callback mode"},
+ {"name": "callback", "type": "buffer map callback"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ "buffer map callback info 2": {
"category": "callback info",
"members": [
{"name": "mode", "type": "callback mode"},
- {"name": "callback", "type": "buffer map callback"}
+ {"name": "callback", "type": "buffer map callback 2"}
+ ]
+ },
+ "buffer map async status": {
+ "category": "enum",
+ "emscripten_no_enum_table": true,
+ "values": [
+ {"value": 1, "name": "success"},
+ {"value": 2, "name": "instance dropped"},
+ {"value": 3, "name": "validation error"},
+ {"value": 4, "name": "unknown"},
+ {"value": 5, "name": "device lost"},
+ {"value": 6, "name": "destroyed before callback"},
+ {"value": 7, "name": "unmapped before callback"},
+ {"value": 8, "name": "mapping already pending"},
+ {"value": 9, "name": "offset out of range"},
+ {"value": 10, "name": "size out of range"}
]
},
"map async status": {
@@ -937,6 +993,14 @@
]
},
"compilation info callback": {
+ "category": "function pointer",
+ "args": [
+ {"name": "status", "type": "compilation info request status"},
+ {"name": "compilation info", "type": "compilation info", "annotation": "const*"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ "compilation info callback 2": {
"category": "callback function",
"args": [
{"name": "status", "type": "compilation info request status"},
@@ -944,10 +1008,19 @@
]
},
"compilation info callback info": {
+ "category": "structure",
+ "extensible": "in",
+ "members": [
+ {"name": "mode", "type": "callback mode"},
+ {"name": "callback", "type": "compilation info callback"},
+ {"name": "userdata", "type": "void *", "default": "nullptr"}
+ ]
+ },
+ "compilation info callback info 2": {
"category": "callback info",
"members": [
{"name": "mode", "type": "callback mode"},
- {"name": "callback", "type": "compilation info callback"}
+ {"name": "callback", "type": "compilation info callback 2"}
]
},
"compilation info request status": {
@@ -1137,6 +1210,15 @@
]
},
"create compute pipeline async callback": {
+ "category": "function pointer",
+ "args": [
+ {"name": "status", "type": "create pipeline async status"},
+ {"name": "pipeline", "type": "compute pipeline", "optional": true},
+ {"name": "message", "type": "string view"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ "create compute pipeline async callback 2": {
"category": "callback function",
"args": [
{"name": "status", "type": "create pipeline async status"},
@@ -1145,10 +1227,19 @@
]
},
"create compute pipeline async callback info": {
+ "category": "structure",
+ "extensible": "in",
+ "members": [
+ {"name": "mode", "type": "callback mode"},
+ {"name": "callback", "type": "create compute pipeline async callback"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ "create compute pipeline async callback info 2": {
"category": "callback info",
"members": [
{"name": "mode", "type": "callback mode"},
- {"name": "callback", "type": "create compute pipeline async callback"}
+ {"name": "callback", "type": "create compute pipeline async callback 2"}
]
},
"create pipeline async status": {
@@ -1165,6 +1256,15 @@
]
},
"create render pipeline async callback": {
+ "category": "function pointer",
+ "args": [
+ {"name": "status", "type": "create pipeline async status"},
+ {"name": "pipeline", "type": "render pipeline", "optional": true},
+ {"name": "message", "type": "string view"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ "create render pipeline async callback 2": {
"category": "callback function",
"args": [
{"name": "status", "type": "create pipeline async status"},
@@ -1173,10 +1273,19 @@
]
},
"create render pipeline async callback info": {
+ "category": "structure",
+ "extensible": "in",
+ "members": [
+ {"name": "mode", "type": "callback mode"},
+ {"name": "callback", "type": "create render pipeline async callback"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ "create render pipeline async callback info 2": {
"category": "callback info",
"members": [
{"name": "mode", "type": "callback mode"},
- {"name": "callback", "type": "create render pipeline async callback"}
+ {"name": "callback", "type": "create render pipeline async callback 2"}
]
},
"cull mode": {
@@ -1245,6 +1354,17 @@
},
{
"name": "create compute pipeline async",
+ "returns": "void",
+ "args": [
+ {"name": "descriptor", "type": "compute pipeline descriptor", "annotation": "const*"},
+ {"name": "callback", "type": "create compute pipeline async callback"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ {
+ "name": "create compute pipeline async f",
+ "_comment": "TODO(crbug.com/dawn/2021): This is dawn/emscripten-only until we rename it to replace the old API. See bug for details.",
+ "tags": ["dawn", "emscripten"],
"returns": "future",
"args": [
{"name": "descriptor", "type": "compute pipeline descriptor", "annotation": "const*"},
@@ -1252,6 +1372,16 @@
]
},
{
+ "name": "create compute pipeline async 2",
+ "_comment": "TODO(crbug.com/dawn/2021): This is dawn/emscripten-only until we rename it to replace the old API. See bug for details.",
+ "tags": ["dawn", "emscripten"],
+ "returns": "future",
+ "args": [
+ {"name": "descriptor", "type": "compute pipeline descriptor", "annotation": "const*"},
+ {"name": "callback info", "type": "create compute pipeline async callback info 2"}
+ ]
+ },
+ {
"name": "create external texture",
"returns": "external texture",
"tags": ["dawn"],
@@ -1280,6 +1410,17 @@
},
{
"name": "create render pipeline async",
+ "returns": "void",
+ "args": [
+ {"name": "descriptor", "type": "render pipeline descriptor", "annotation": "const*"},
+ {"name": "callback", "type": "create render pipeline async callback"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ {
+ "name": "create render pipeline async f",
+ "_comment": "TODO(crbug.com/dawn/2021): This is dawn/emscripten-only until we rename it to replace the old API. See bug for details.",
+ "tags": ["dawn", "emscripten"],
"returns": "future",
"args": [
{"name": "descriptor", "type": "render pipeline descriptor", "annotation": "const*"},
@@ -1287,6 +1428,16 @@
]
},
{
+ "name": "create render pipeline async 2",
+ "_comment": "TODO(crbug.com/dawn/2021): This is dawn/emscripten-only until we rename it to replace the old API. See bug for details.",
+ "tags": ["dawn", "emscripten"],
+ "returns": "future",
+ "args": [
+ {"name": "descriptor", "type": "render pipeline descriptor", "annotation": "const*"},
+ {"name": "callback info", "type": "create render pipeline async callback info 2"}
+ ]
+ },
+ {
"name": "create render bundle encoder",
"returns": "render bundle encoder",
"args": [
@@ -1456,12 +1607,30 @@
{
"name": "pop error scope",
"no autolock": true,
+ "args": [
+ {"name": "old callback", "type": "error callback"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ {
+ "name": "pop error scope f",
+ "_comment": "TODO(crbug.com/dawn/2021): This is dawn/emscripten-only until we rename it to replace the old API. See bug for details.",
+ "tags": ["dawn", "emscripten"],
"returns": "future",
"args": [
{"name": "callback info", "type": "pop error scope callback info"}
]
},
{
+ "name": "pop error scope 2",
+ "_comment": "TODO(crbug.com/dawn/2021): This is dawn/emscripten-only until we rename it to replace the old API. See bug for details.",
+ "tags": ["dawn", "emscripten"],
+ "returns": "future",
+ "args": [
+ {"name": "callback info", "type": "pop error scope callback info 2"}
+ ]
+ },
+ {
"name": "set label",
"returns": "void",
"args": [
@@ -1572,6 +1741,15 @@
]
},
"pop error scope callback": {
+ "category": "function pointer",
+ "args": [
+ {"name": "status", "type": "pop error scope status"},
+ {"name": "type", "type": "error type"},
+ {"name": "message", "type": "string view"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ "pop error scope callback 2": {
"category": "callback function",
"args": [
{"name": "status", "type": "pop error scope status"},
@@ -1580,10 +1758,20 @@
]
},
"pop error scope callback info": {
+ "category": "structure",
+ "extensible": "in",
+ "members": [
+ {"name": "mode", "type": "callback mode", "default": "wait any only"},
+ {"name": "callback", "type": "pop error scope callback"},
+ {"name": "old callback", "type": "error callback", "_comment": "TODO(crbug.com/dawn/2021) Deprecate this field once we have moved callers to use the new callback signature."},
+ {"name": "userdata", "type": "void *", "default": "nullptr"}
+ ]
+ },
+ "pop error scope callback info 2": {
"category": "callback info",
"members": [
{"name": "mode", "type": "callback mode"},
- {"name": "callback", "type": "pop error scope callback"}
+ {"name": "callback", "type": "pop error scope callback 2"}
]
},
"limits": {
@@ -2760,12 +2948,31 @@
},
{
"name": "on submitted work done",
+ "tags": ["dawn", "upstream"],
+ "args": [
+ {"name": "callback", "type": "queue work done callback"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ {
+ "name": "on submitted work done f",
+ "_comment": "TODO(crbug.com/dawn/2021): This is dawn/emscripten-only until we rename it to replace the old API. See bug for details.",
+ "tags": ["dawn", "emscripten"],
"returns": "future",
"args": [
{"name": "callback info", "type": "queue work done callback info"}
]
},
{
+ "name": "on submitted work done 2",
+ "_comment": "TODO(crbug.com/dawn/2021): This is dawn/emscripten-only until we rename it to replace the old API. See bug for details.",
+ "tags": ["dawn", "emscripten"],
+ "returns": "future",
+ "args": [
+ {"name": "callback info", "type": "queue work done callback info 2"}
+ ]
+ },
+ {
"name": "write buffer",
"args": [
{"name": "buffer", "type": "buffer"},
@@ -2823,16 +3030,32 @@
]
},
"queue work done callback": {
+ "category": "function pointer",
+ "args": [
+ {"name": "status", "type": "queue work done status"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ "queue work done callback 2": {
"category": "callback function",
"args": [
{"name": "status", "type": "queue work done status"}
]
},
"queue work done callback info": {
+ "category": "structure",
+ "extensible": "in",
+ "members": [
+ {"name": "mode", "type": "callback mode"},
+ {"name": "callback", "type": "queue work done callback"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ "queue work done callback info 2": {
"category": "callback info",
"members": [
{"name": "mode", "type": "callback mode"},
- {"name": "callback", "type": "queue work done callback"}
+ {"name": "callback", "type": "queue work done callback 2"}
]
},
"queue work done status": {
@@ -2842,7 +3065,8 @@
{"value": 1, "name": "success"},
{"value": 2, "name": "instance dropped"},
{"value": 3, "name": "error"},
- {"value": 4, "name": "unknown"}
+ {"value": 4, "name": "unknown"},
+ {"value": 5, "name": "device lost"}
]
},
@@ -3472,12 +3696,30 @@
"methods": [
{
"name": "get compilation info",
+ "args": [
+ {"name": "callback", "type": "compilation info callback"},
+ {"name": "userdata", "type": "void *"}
+ ]
+ },
+ {
+ "name": "get compilation info f",
+ "_comment": "TODO(crbug.com/dawn/2021): This is dawn/emscripten-only until we rename it to replace the old API. See bug for details.",
+ "tags": ["dawn", "emscripten"],
"returns": "future",
"args": [
{"name": "callback info", "type": "compilation info callback info"}
]
},
{
+ "name": "get compilation info 2",
+ "_comment": "TODO(crbug.com/dawn/2021): This is dawn/emscripten-only until we rename it to replace the old API. See bug for details.",
+ "tags": ["dawn", "emscripten"],
+ "returns": "future",
+ "args": [
+ {"name": "callback info", "type": "compilation info callback info 2"}
+ ]
+ },
+ {
"name": "set label",
"returns": "void",
"args": [
diff --git a/src/dawn/dawn_wire.json b/src/dawn/dawn_wire.json
index cc67fcd..97b23ea 100644
--- a/src/dawn/dawn_wire.json
+++ b/src/dawn/dawn_wire.json
@@ -37,7 +37,8 @@
{ "name": "future", "type": "future" },
{ "name": "mode", "type": "map mode" },
{ "name": "offset", "type": "uint64_t"},
- { "name": "size", "type": "uint64_t"}
+ { "name": "size", "type": "uint64_t"},
+ { "name": "userdata count", "type": "uint8_t", "_comment": "TODO(crbug.com/dawn/2509): Remove this once Chromium overrides the correct functions in the proc table."}
],
"buffer update mapped data": [
{ "name": "buffer id", "type": "ObjectId", "id_type": "buffer" },
@@ -81,7 +82,8 @@
"queue on submitted work done": [
{ "name": "queue id", "type": "ObjectId", "id_type": "queue" },
{ "name": "event manager handle", "type": "ObjectHandle" },
- { "name": "future", "type": "future" }
+ { "name": "future", "type": "future" },
+ { "name": "userdata count", "type": "uint8_t", "_comment": "TODO(crbug.com/dawn/2509): Remove this once Chromium overrides the correct functions in the proc table."}
],
"queue write buffer": [
{"name": "queue id", "type": "ObjectId", "id_type": "queue" },
@@ -130,8 +132,10 @@
"buffer map async callback": [
{ "name": "event manager", "type": "ObjectHandle" },
{ "name": "future", "type": "future" },
- { "name": "status", "type": "map async status" },
+ { "name": "status", "type": "buffer map async status" },
+ { "name": "status2", "type": "map async status" },
{ "name": "message", "type": "string view" },
+ { "name": "userdata count", "type": "uint8_t", "_comment": "TODO(crbug.com/dawn/2509): Remove this once Chromium overrides the correct functions in the proc table."},
{ "name": "read data update info length", "type": "uint64_t" },
{ "name": "read data update info", "type": "uint8_t", "annotation": "const*", "length": "read data update info length", "skip_serialize": true }
],
@@ -224,6 +228,8 @@
"AdapterRequestDeviceF",
"AdapterRequestDevice2",
"BufferMapAsync",
+ "BufferMapAsyncF",
+ "BufferMapAsync2",
"BufferGetConstMappedRange",
"BufferGetMappedRange",
"BufferGetMapState",
@@ -231,7 +237,11 @@
"BufferGetUsage",
"DeviceCreateBuffer",
"DeviceCreateComputePipelineAsync",
+ "DeviceCreateComputePipelineAsyncF",
+ "DeviceCreateComputePipelineAsync2",
"DeviceCreateRenderPipelineAsync",
+ "DeviceCreateRenderPipelineAsyncF",
+ "DeviceCreateRenderPipelineAsync2",
"DeviceGetAdapter",
"DeviceGetAdapterInfo",
"DeviceGetFeatures",
@@ -249,9 +259,13 @@
"InstanceRequestAdapterF",
"InstanceRequestAdapter2",
"ShaderModuleGetCompilationInfo",
+ "ShaderModuleGetCompilationInfoF",
+ "ShaderModuleGetCompilationInfo2",
"QuerySetGetType",
"QuerySetGetCount",
"QueueOnSubmittedWorkDone",
+ "QueueOnSubmittedWorkDoneF",
+ "QueueOnSubmittedWorkDone2",
"QueueWriteBuffer",
"QueueWriteTexture",
"SurfaceGetCapabilities",
diff --git a/src/dawn/native/Buffer.cpp b/src/dawn/native/Buffer.cpp
index 0b70008..c38e2a7 100644
--- a/src/dawn/native/Buffer.cpp
+++ b/src/dawn/native/Buffer.cpp
@@ -59,6 +59,34 @@
namespace dawn::native {
namespace {
+struct MapRequestTask : TrackTaskCallback {
+ MapRequestTask(dawn::platform::Platform* platform, Ref<BufferBase> buffer, MapRequestID id)
+ : TrackTaskCallback(platform), buffer(std::move(buffer)), id(id) {}
+ ~MapRequestTask() override = default;
+
+ private:
+ void FinishImpl() override {
+ {
+ // This is called from a callback, and no lock will be held by default. Hence, we need
+ // to lock the mutex now because mSerial might be changed by another thread.
+ auto deviceLock(buffer->GetDevice()->GetScopedLock());
+ DAWN_ASSERT(mSerial != kMaxExecutionSerial);
+ TRACE_EVENT1(mPlatform, General, "Buffer::TaskInFlight::Finished", "serial",
+ uint64_t(mSerial));
+ }
+ buffer->CallbackOnMapRequestCompleted(id, WGPUBufferMapAsyncStatus_Success);
+ }
+ void HandleDeviceLossImpl() override {
+ buffer->CallbackOnMapRequestCompleted(id, WGPUBufferMapAsyncStatus_DeviceLost);
+ }
+ void HandleShutDownImpl() override {
+ buffer->CallbackOnMapRequestCompleted(id, WGPUBufferMapAsyncStatus_DestroyedBeforeCallback);
+ }
+
+ Ref<BufferBase> buffer;
+ MapRequestID id;
+};
+
class ErrorBuffer final : public BufferBase {
public:
ErrorBuffer(DeviceBase* device, const BufferDescriptor* descriptor)
@@ -155,7 +183,106 @@
} // anonymous namespace
-struct BufferBase::MapAsyncEvent final : public EventManager::TrackedEvent {
+struct BufferBase::MapAsyncEvent : public EventManager::TrackedEvent {
+ MapAsyncEvent(wgpu::CallbackMode mode, QueueBase* queue, ExecutionSerial serial)
+ : TrackedEvent(mode, queue, serial) {}
+ // TODO(crbug.com/42241006): Note that currently this constructor is used for errors because a
+ // dropped device can result in failure when trying to get the queue. While using this fixes the
+ // problem, it causes an unintentional side-effect where it is possible to run into a
+ // UnsupportedMixedSource error on WaitAny even if we are only using a single device with
+ // MapAsync calls. This will be fixed once we correctly implement mixed sources.
+ explicit MapAsyncEvent(wgpu::CallbackMode mode)
+ : TrackedEvent(mode, SystemEvent::CreateSignaled()) {}
+
+ virtual void UnmapEarly(wgpu::BufferMapAsyncStatus status) = 0;
+};
+
+struct BufferBase::MapAsyncEvent1 final : public BufferBase::MapAsyncEvent {
+ // MapAsyncEvent stores a raw pointer to the buffer so that it can
+ // update the buffer's map state when it completes.
+ // If the map completes early (error, unmap, destroy), then the buffer
+ // is no longer needed and we store the early status instead.
+ // The raw pointer is safe because the early status is set to destroyed
+ // before the buffer is dropped.
+ // Note: this could be an atomic + spin lock on a sentinel enum if the mutex
+ // cost is high.
+ MutexProtected<std::variant<BufferBase*, wgpu::BufferMapAsyncStatus>> mBufferOrEarlyStatus;
+
+ WGPUBufferMapCallback mCallback;
+ raw_ptr<void> mUserdata;
+
+ // Create an event backed by the given queue execution serial.
+ MapAsyncEvent1(DeviceBase* device,
+ BufferBase* buffer,
+ const BufferMapCallbackInfo& callbackInfo,
+ ExecutionSerial serial)
+ : MapAsyncEvent(callbackInfo.mode, device->GetQueue(), serial),
+ mBufferOrEarlyStatus(buffer),
+ mCallback(callbackInfo.callback),
+ mUserdata(callbackInfo.userdata) {
+ TRACE_EVENT_ASYNC_BEGIN0(device->GetPlatform(), General, "Buffer::APIMapAsync",
+ uint64_t(serial));
+ }
+
+ // Create an event that's ready at creation (for errors, etc.)
+ MapAsyncEvent1(DeviceBase* device,
+ const BufferMapCallbackInfo& callbackInfo,
+ wgpu::BufferMapAsyncStatus earlyStatus)
+ : MapAsyncEvent(callbackInfo.mode, device->GetQueue(), kBeginningOfGPUTime),
+ mBufferOrEarlyStatus(earlyStatus),
+ mCallback(callbackInfo.callback),
+ mUserdata(callbackInfo.userdata) {
+ TRACE_EVENT_ASYNC_BEGIN0(device->GetPlatform(), General, "Buffer::APIMapAsync",
+ uint64_t(kBeginningOfGPUTime));
+ }
+
+ ~MapAsyncEvent1() override { EnsureComplete(EventCompletionType::Shutdown); }
+
+ void Complete(EventCompletionType completionType) override {
+ if (const auto* queueAndSerial = std::get_if<QueueAndSerial>(&GetCompletionData())) {
+ TRACE_EVENT_ASYNC_END0(queueAndSerial->queue->GetDevice()->GetPlatform(), General,
+ "Buffer::APIMapAsync",
+ uint64_t(queueAndSerial->completionSerial));
+ }
+
+ if (completionType == EventCompletionType::Shutdown) {
+ mCallback(ToAPI(wgpu::BufferMapAsyncStatus::InstanceDropped), mUserdata);
+ return;
+ }
+
+ wgpu::BufferMapAsyncStatus status = wgpu::BufferMapAsyncStatus::Success;
+ Ref<MapAsyncEvent> pendingMapEvent;
+
+ // Lock the buffer / early status. This may race with UnmapEarly which occurs
+ // when the buffer is unmapped or destroyed.
+ mBufferOrEarlyStatus.Use([&](auto bufferOrEarlyStatus) {
+ if (auto* earlyStatus =
+ std::get_if<wgpu::BufferMapAsyncStatus>(&*bufferOrEarlyStatus)) {
+ // Assign the early status, if it was set.
+ status = *earlyStatus;
+ } else if (auto** buffer = std::get_if<BufferBase*>(&*bufferOrEarlyStatus)) {
+ // Set the buffer state to Mapped if this pending map succeeded.
+ // TODO(crbug.com/dawn/831): in order to be thread safe, mutation of the
+ // state and pending map event needs to be atomic w.r.t. UnmapInternal.
+ DAWN_ASSERT((*buffer)->mState == BufferState::PendingMap);
+ (*buffer)->mState = BufferState::Mapped;
+
+ pendingMapEvent = std::move((*buffer)->mPendingMapEvent);
+ }
+ });
+ mCallback(ToAPI(status), mUserdata);
+ }
+
+ // Set the buffer early status because it was unmapped early due to Unmap or Destroy.
+ // This can race with Complete such that the early status is ignored, but this is OK
+ // because we will still unmap the buffer. It will be as-if the application called
+ // Unmap/Destroy just after the map event completed.
+ void UnmapEarly(wgpu::BufferMapAsyncStatus status) override {
+ mBufferOrEarlyStatus.Use([&](auto bufferOrEarlyStatus) { *bufferOrEarlyStatus = status; });
+ }
+};
+
+struct BufferBase::MapAsyncEvent2 final : public BufferBase::MapAsyncEvent {
// MapAsyncEvent stores a raw pointer to the buffer so that it can update the buffer's map state
// when it completes. If the map completes early (error, unmap, destroy), then the buffer is no
// longer needed and we store the early status instead. The raw pointer is safe because the
@@ -167,18 +294,18 @@
};
MutexProtected<std::variant<BufferBase*, BufferErrorData>> mBufferOrError;
- WGPUBufferMapCallback mCallback;
+ WGPUBufferMapCallback2 mCallback;
raw_ptr<void> mUserdata1;
raw_ptr<void> mUserdata2;
// Create an event backed by the given queue execution serial.
- MapAsyncEvent(DeviceBase* device,
- BufferBase* buffer,
- const WGPUBufferMapCallbackInfo& callbackInfo,
- ExecutionSerial serial)
- : TrackedEvent(static_cast<wgpu::CallbackMode>(callbackInfo.mode),
- device->GetQueue(),
- serial),
+ MapAsyncEvent2(DeviceBase* device,
+ BufferBase* buffer,
+ const WGPUBufferMapCallbackInfo2& callbackInfo,
+ ExecutionSerial serial)
+ : MapAsyncEvent(static_cast<wgpu::CallbackMode>(callbackInfo.mode),
+ device->GetQueue(),
+ serial),
mBufferOrError(buffer),
mCallback(callbackInfo.callback),
mUserdata1(callbackInfo.userdata1),
@@ -188,13 +315,16 @@
}
// Create an event that's ready at creation (for errors, etc.)
- MapAsyncEvent(DeviceBase* device,
- const WGPUBufferMapCallbackInfo& callbackInfo,
- const std::string& message,
- WGPUMapAsyncStatus status)
- : TrackedEvent(static_cast<wgpu::CallbackMode>(callbackInfo.mode),
- SystemEvent::CreateSignaled()),
- mBufferOrError(BufferErrorData{status, message}),
+ MapAsyncEvent2(DeviceBase* device,
+ const WGPUBufferMapCallbackInfo2& callbackInfo,
+ const std::string& message,
+ WGPUBufferMapAsyncStatus status)
+ : MapAsyncEvent(static_cast<wgpu::CallbackMode>(callbackInfo.mode)),
+ mBufferOrError(BufferErrorData{
+ status == WGPUBufferMapAsyncStatus_ValidationError ? WGPUMapAsyncStatus_Error
+ : status == WGPUBufferMapAsyncStatus_DeviceLost ? WGPUMapAsyncStatus_Aborted
+ : WGPUMapAsyncStatus_Unknown,
+ message}),
mCallback(callbackInfo.callback),
mUserdata1(callbackInfo.userdata1),
mUserdata2(callbackInfo.userdata2) {
@@ -202,7 +332,7 @@
uint64_t(kBeginningOfGPUTime));
}
- ~MapAsyncEvent() override { EnsureComplete(EventCompletionType::Shutdown); }
+ ~MapAsyncEvent2() override { EnsureComplete(EventCompletionType::Shutdown); }
void Complete(EventCompletionType completionType) override {
if (const auto* queueAndSerial = std::get_if<QueueAndSerial>(&GetCompletionData())) {
@@ -255,9 +385,21 @@
// This can race with Complete such that the early status is ignored, but this is OK
// because we will still unmap the buffer. It will be as-if the application called
// Unmap/Destroy just after the map event completed.
- void UnmapEarly(WGPUMapAsyncStatus status, std::string_view message) {
+ void UnmapEarly(wgpu::BufferMapAsyncStatus status) override {
+ auto StatusToMessage = [](wgpu::BufferMapAsyncStatus status) {
+ switch (status) {
+ case wgpu::BufferMapAsyncStatus::DeviceLost:
+ return "Device was lost.";
+ case wgpu::BufferMapAsyncStatus::DestroyedBeforeCallback:
+ return "Buffer was destroyed before mapping was resolved.";
+ case wgpu::BufferMapAsyncStatus::UnmappedBeforeCallback:
+ return "Buffer was unmapped before mapping was resolved.";
+ default:
+ DAWN_UNREACHABLE();
+ }
+ };
mBufferOrError.Use([&](auto bufferOrError) {
- *bufferOrError = BufferErrorData{status, std::string(message)};
+ *bufferOrError = BufferErrorData{WGPUMapAsyncStatus_Aborted, StatusToMessage(status)};
});
}
};
@@ -368,14 +510,12 @@
// is implicitly destroyed. This case is thread-safe because there are no
// other threads using the buffer since there are no other live refs.
if (mState == BufferState::Mapped || mState == BufferState::PendingMap) {
- UnmapInternal(WGPUMapAsyncStatus_Aborted,
- "Buffer was destroyed before mapping was resolved.");
+ UnmapInternal(WGPUBufferMapAsyncStatus_DestroyedBeforeCallback);
} else if (mState == BufferState::MappedAtCreation) {
if (mStagingBuffer != nullptr) {
mStagingBuffer = nullptr;
} else if (mSize != 0) {
- UnmapInternal(WGPUMapAsyncStatus_Aborted,
- "Buffer was destroyed before mapping was resolved.");
+ UnmapInternal(WGPUBufferMapAsyncStatus_DestroyedBeforeCallback);
}
}
@@ -529,10 +669,151 @@
DAWN_UNREACHABLE();
}
-Future BufferBase::APIMapAsync(wgpu::MapMode mode,
- size_t offset,
- size_t size,
- const WGPUBufferMapCallbackInfo& callbackInfo) {
+std::function<void()> BufferBase::PrepareMappingCallback(MapRequestID mapID,
+ WGPUBufferMapAsyncStatus status) {
+ DAWN_ASSERT(!IsError());
+
+ if (mMapCallback != nullptr && mapID == mLastMapID) {
+ auto callback = std::move(mMapCallback);
+ void* userdata = std::move(mMapUserdata);
+ WGPUBufferMapAsyncStatus actualStatus;
+ if (GetDevice()->IsLost()) {
+ actualStatus = WGPUBufferMapAsyncStatus_DeviceLost;
+ } else {
+ actualStatus = status;
+ }
+
+ // Tag the callback as fired before firing it, otherwise it could fire a second time if
+ // for example buffer.Unmap() is called before the MapRequestTask completes.
+ mMapCallback = nullptr;
+ mMapUserdata = nullptr;
+
+ return std::bind(callback, actualStatus, userdata);
+ }
+
+ return [] {};
+}
+
+void BufferBase::APIMapAsync(wgpu::MapMode mode,
+ size_t offset,
+ size_t size,
+ WGPUBufferMapCallback callback,
+ void* userdata) {
+ GetInstance()->EmitDeprecationWarning(
+ "Old MapAsync APIs are deprecated. If using C please pass a CallbackInfo "
+ "struct that has two userdatas. Otherwise, if using C++, please use templated helpers.");
+
+ // Check for an existing pending map first because it just
+ // rejects the callback and doesn't produce a validation error.
+ if (mState == BufferState::PendingMap) {
+ if (callback) {
+ GetDevice()->GetCallbackTaskManager()->AddCallbackTask(
+ callback, WGPUBufferMapAsyncStatus_MappingAlreadyPending, userdata);
+ }
+ return;
+ }
+
+ // Handle the defaulting of size required by WebGPU, even if in webgpu_cpp.h it is not
+ // possible to default the function argument (because there is the callback later in the
+ // argument list)
+ if ((size == wgpu::kWholeMapSize) && (offset <= mSize)) {
+ size = mSize - offset;
+ }
+
+ WGPUBufferMapAsyncStatus status;
+ if (GetDevice()->ConsumedError(ValidateMapAsync(mode, offset, size, &status),
+ "calling %s.MapAsync(%s, %u, %u, ...).", this, mode, offset,
+ size)) {
+ if (callback) {
+ GetDevice()->GetCallbackTaskManager()->AddCallbackTask(callback, status, userdata);
+ }
+ return;
+ }
+ DAWN_ASSERT(!IsError());
+
+ mLastMapID++;
+ mMapMode = mode;
+ mMapOffset = offset;
+ mMapSize = size;
+ mMapCallback = callback;
+ mMapUserdata = userdata;
+ mState = BufferState::PendingMap;
+
+ if (GetDevice()->ConsumedError(MapAsyncImpl(mode, offset, size))) {
+ GetDevice()->GetCallbackTaskManager()->AddCallbackTask(
+ PrepareMappingCallback(mLastMapID, WGPUBufferMapAsyncStatus_DeviceLost));
+ return;
+ }
+ std::unique_ptr<MapRequestTask> request =
+ std::make_unique<MapRequestTask>(GetDevice()->GetPlatform(), this, mLastMapID);
+ TRACE_EVENT1(GetDevice()->GetPlatform(), General, "Buffer::APIMapAsync", "serial",
+ uint64_t(mLastUsageSerial));
+ GetDevice()->GetQueue()->TrackTask(std::move(request), mLastUsageSerial);
+}
+
+Future BufferBase::APIMapAsyncF(wgpu::MapMode mode,
+ size_t offset,
+ size_t size,
+ const BufferMapCallbackInfo& callbackInfo) {
+ GetInstance()->EmitDeprecationWarning(
+ "Old MapAsync APIs are deprecated. If using C please pass a CallbackInfo "
+ "struct that has two userdatas. Otherwise, if using C++, please use templated helpers.");
+
+ // TODO(crbug.com/dawn/2052): Once we always return a future, change this to log to the instance
+ // (note, not raise a validation error to the device) and return the null future.
+ DAWN_ASSERT(callbackInfo.nextInChain == nullptr);
+
+ Ref<EventManager::TrackedEvent> event;
+ std::optional<wgpu::BufferMapAsyncStatus> earlyStatus;
+ {
+ // TODO(crbug.com/dawn/831) Manually acquire device lock instead of relying on code-gen for
+ // re-entrancy.
+ auto deviceLock(GetDevice()->GetScopedLock());
+
+ // Handle the defaulting of size required by WebGPU, even if in webgpu_cpp.h it is not
+ // possible to default the function argument (because there is the callback later in the
+ // argument list)
+ if ((size == wgpu::kWholeMapSize) && (offset <= mSize)) {
+ size = mSize - offset;
+ }
+
+ earlyStatus = [&]() -> std::optional<wgpu::BufferMapAsyncStatus> {
+ if (mState == BufferState::PendingMap) {
+ return wgpu::BufferMapAsyncStatus::MappingAlreadyPending;
+ }
+ WGPUBufferMapAsyncStatus status;
+ if (GetDevice()->ConsumedError(ValidateMapAsync(mode, offset, size, &status),
+ "calling %s.MapAsync(%s, %u, %u, ...).", this, mode,
+ offset, size)) {
+ return static_cast<wgpu::BufferMapAsyncStatus>(status);
+ }
+ if (GetDevice()->ConsumedError(MapAsyncImpl(mode, offset, size))) {
+ return wgpu::BufferMapAsyncStatus::DeviceLost;
+ }
+ return std::nullopt;
+ }();
+
+ if (earlyStatus) {
+ event = AcquireRef(new MapAsyncEvent1(GetDevice(), callbackInfo, *earlyStatus));
+ } else {
+ mMapMode = mode;
+ mMapOffset = offset;
+ mMapSize = size;
+ mState = BufferState::PendingMap;
+ mPendingMapEvent =
+ AcquireRef(new MapAsyncEvent1(GetDevice(), this, callbackInfo, mLastUsageSerial));
+ event = mPendingMapEvent;
+ }
+ }
+
+ FutureID futureID = GetInstance()->GetEventManager()->TrackEvent(std::move(event));
+ return {futureID};
+}
+
+Future BufferBase::APIMapAsync2(wgpu::MapMode mode,
+ size_t offset,
+ size_t size,
+ const WGPUBufferMapCallbackInfo2& callbackInfo) {
// TODO(crbug.com/dawn/2052): Once we always return a future, change this to log to the instance
// (note, not raise a validation error to the device) and return the null future.
DAWN_ASSERT(callbackInfo.nextInChain == nullptr);
@@ -550,7 +831,7 @@
size = mSize - offset;
}
- WGPUMapAsyncStatus status = WGPUMapAsyncStatus_Error;
+ WGPUBufferMapAsyncStatus status = WGPUBufferMapAsyncStatus_ValidationError;
MaybeError maybeError = [&]() -> MaybeError {
DAWN_INVALID_IF(mState == BufferState::PendingMap,
"%s already has an outstanding map pending.", this);
@@ -562,7 +843,7 @@
if (maybeError.IsError()) {
auto error = maybeError.AcquireError();
event = AcquireRef(
- new MapAsyncEvent(GetDevice(), callbackInfo, error->GetMessage(), status));
+ new MapAsyncEvent2(GetDevice(), callbackInfo, error->GetMessage(), status));
[[maybe_unused]] bool hadError = GetDevice()->ConsumedError(
std::move(error), "calling %s.MapAsync(%s, %u, %u, ...).", this, mode, offset,
size);
@@ -572,7 +853,7 @@
mMapSize = size;
mState = BufferState::PendingMap;
mPendingMapEvent =
- AcquireRef(new MapAsyncEvent(GetDevice(), this, callbackInfo, mLastUsageSerial));
+ AcquireRef(new MapAsyncEvent2(GetDevice(), this, callbackInfo, mLastUsageSerial));
event = mPendingMapEvent;
}
}
@@ -640,18 +921,23 @@
if (mState == BufferState::MappedAtCreation && mStagingBuffer != nullptr) {
DAWN_TRY(CopyFromStagingBuffer());
}
- UnmapInternal(WGPUMapAsyncStatus_Aborted, "Buffer was unmapped before mapping was resolved.");
+ UnmapInternal(WGPUBufferMapAsyncStatus_UnmappedBeforeCallback);
return {};
}
-void BufferBase::UnmapInternal(WGPUMapAsyncStatus status, std::string_view message) {
+void BufferBase::UnmapInternal(WGPUBufferMapAsyncStatus callbackStatus) {
// Unmaps resources on the backend.
if (mState == BufferState::PendingMap) {
// TODO(crbug.com/dawn/831): in order to be thread safe, mutation of the
// state and pending map event needs to be atomic w.r.t. MapAsyncEvent::Complete.
Ref<MapAsyncEvent> pendingMapEvent = std::move(mPendingMapEvent);
- pendingMapEvent->UnmapEarly(status, message);
- GetInstance()->GetEventManager()->SetFutureReady(pendingMapEvent.Get());
+ if (pendingMapEvent != nullptr) {
+ pendingMapEvent->UnmapEarly(static_cast<wgpu::BufferMapAsyncStatus>(callbackStatus));
+ GetInstance()->GetEventManager()->SetFutureReady(pendingMapEvent.Get());
+ } else {
+ GetDevice()->GetCallbackTaskManager()->AddCallbackTask(
+ PrepareMappingCallback(mLastMapID, callbackStatus));
+ }
UnmapImpl();
} else if (mState == BufferState::Mapped) {
UnmapImpl();
@@ -667,11 +953,11 @@
MaybeError BufferBase::ValidateMapAsync(wgpu::MapMode mode,
size_t offset,
size_t size,
- WGPUMapAsyncStatus* status) const {
- *status = WGPUMapAsyncStatus_Aborted;
+ WGPUBufferMapAsyncStatus* status) const {
+ *status = WGPUBufferMapAsyncStatus_DeviceLost;
DAWN_TRY(GetDevice()->ValidateIsAlive());
- *status = WGPUMapAsyncStatus_Error;
+ *status = WGPUBufferMapAsyncStatus_ValidationError;
DAWN_TRY(GetDevice()->ValidateObject(this));
DAWN_INVALID_IF(uint64_t(offset) > mSize,
@@ -716,7 +1002,7 @@
wgpu::BufferUsage::MapWrite);
}
- *status = WGPUMapAsyncStatus_Success;
+ *status = WGPUBufferMapAsyncStatus_Success;
return {};
}
@@ -775,6 +1061,22 @@
return {};
}
+void BufferBase::CallbackOnMapRequestCompleted(MapRequestID mapID,
+ WGPUBufferMapAsyncStatus status) {
+ {
+ // This is called from a callback, and no lock will be held by default. Hence, we need to
+ // lock the mutex now because this will modify the buffer's states.
+ auto deviceLock(GetDevice()->GetScopedLock());
+ if (mapID == mLastMapID && status == WGPUBufferMapAsyncStatus_Success &&
+ mState == BufferState::PendingMap) {
+ mState = BufferState::Mapped;
+ }
+ }
+
+ auto cb = PrepareMappingCallback(mapID, status);
+ cb();
+}
+
bool BufferBase::NeedsInitialization() const {
return !mIsDataInitialized && GetDevice()->IsToggleEnabled(Toggle::LazyClearResourceOnFirstUse);
}
diff --git a/src/dawn/native/Buffer.h b/src/dawn/native/Buffer.h
index cc7d3d6..7f130e6 100644
--- a/src/dawn/native/Buffer.h
+++ b/src/dawn/native/Buffer.h
@@ -95,6 +95,7 @@
wgpu::BufferUsage GetUsage() const;
MaybeError MapAtCreation();
+ void CallbackOnMapRequestCompleted(MapRequestID mapID, WGPUBufferMapAsyncStatus status);
MaybeError ValidateCanUseOnQueueNow() const;
@@ -118,10 +119,19 @@
void DumpMemoryStatistics(dawn::native::MemoryDump* dump, const char* prefix) const;
// Dawn API
- Future APIMapAsync(wgpu::MapMode mode,
- size_t offset,
- size_t size,
- const WGPUBufferMapCallbackInfo& callbackInfo);
+ void APIMapAsync(wgpu::MapMode mode,
+ size_t offset,
+ size_t size,
+ WGPUBufferMapCallback callback,
+ void* userdata);
+ Future APIMapAsyncF(wgpu::MapMode mode,
+ size_t offset,
+ size_t size,
+ const BufferMapCallbackInfo& callbackInfo);
+ Future APIMapAsync2(wgpu::MapMode mode,
+ size_t offset,
+ size_t size,
+ const WGPUBufferMapCallbackInfo2& callbackInfo);
void* APIGetMappedRange(size_t offset, size_t size);
const void* APIGetConstMappedRange(size_t offset, size_t size);
void APIUnmap();
@@ -145,6 +155,9 @@
ExecutionSerial mLastUsageSerial = ExecutionSerial(0);
private:
+ std::function<void()> PrepareMappingCallback(MapRequestID mapID,
+ WGPUBufferMapAsyncStatus status);
+
virtual MaybeError MapAtCreationImpl() = 0;
virtual MaybeError MapAsyncImpl(wgpu::MapMode mode, size_t offset, size_t size) = 0;
virtual void UnmapImpl() = 0;
@@ -155,10 +168,10 @@
MaybeError ValidateMapAsync(wgpu::MapMode mode,
size_t offset,
size_t size,
- WGPUMapAsyncStatus* status) const;
+ WGPUBufferMapAsyncStatus* status) const;
MaybeError ValidateUnmap() const;
bool CanGetMappedRange(bool writable, size_t offset, size_t size) const;
- void UnmapInternal(WGPUMapAsyncStatus status, std::string_view message);
+ void UnmapInternal(WGPUBufferMapAsyncStatus callbackStatus);
const uint64_t mSize = 0;
const wgpu::BufferUsage mUsage = wgpu::BufferUsage::None;
@@ -174,11 +187,16 @@
// i.e. buffer->mStagingBuffer->mStagingBuffer... is not possible.
Ref<BufferBase> mStagingBuffer;
+ WGPUBufferMapCallback mMapCallback = nullptr;
+ raw_ptr<void> mMapUserdata = nullptr;
+ MapRequestID mLastMapID = MapRequestID(0);
wgpu::MapMode mMapMode = wgpu::MapMode::None;
size_t mMapOffset = 0;
size_t mMapSize = 0;
struct MapAsyncEvent;
+ struct MapAsyncEvent1;
+ struct MapAsyncEvent2;
Ref<MapAsyncEvent> mPendingMapEvent;
};
diff --git a/src/dawn/native/CreatePipelineAsyncEvent.cpp b/src/dawn/native/CreatePipelineAsyncEvent.cpp
index 4b79627..854c7ff 100644
--- a/src/dawn/native/CreatePipelineAsyncEvent.cpp
+++ b/src/dawn/native/CreatePipelineAsyncEvent.cpp
@@ -54,15 +54,15 @@
template <>
const char* CreatePipelineAsyncEvent<
ComputePipelineBase,
- WGPUCreateComputePipelineAsyncCallbackInfo>::kDawnHistogramMetricsSuccess =
+ WGPUCreateComputePipelineAsyncCallbackInfo2>::kDawnHistogramMetricsSuccess =
"CreateComputePipelineSuccess";
template <>
const char*
CreatePipelineAsyncEvent<ComputePipelineBase,
- WGPUCreateComputePipelineAsyncCallbackInfo>::kDawnHistogramMetricsUS =
+ WGPUCreateComputePipelineAsyncCallbackInfo2>::kDawnHistogramMetricsUS =
"CreateComputePipelineUS";
template <>
-void CreatePipelineAsyncEvent<ComputePipelineBase, WGPUCreateComputePipelineAsyncCallbackInfo>::
+void CreatePipelineAsyncEvent<ComputePipelineBase, WGPUCreateComputePipelineAsyncCallbackInfo2>::
AddOrGetCachedPipeline() {
DeviceBase* device = mPipeline->GetDevice();
auto deviceLock(device->GetScopedLock());
@@ -74,16 +74,16 @@
template <>
const char* CreatePipelineAsyncEvent<
RenderPipelineBase,
- WGPUCreateRenderPipelineAsyncCallbackInfo>::kDawnHistogramMetricsSuccess =
+ WGPUCreateRenderPipelineAsyncCallbackInfo2>::kDawnHistogramMetricsSuccess =
"CreateRenderPipelineSuccess";
template <>
const char*
CreatePipelineAsyncEvent<RenderPipelineBase,
- WGPUCreateRenderPipelineAsyncCallbackInfo>::kDawnHistogramMetricsUS =
+ WGPUCreateRenderPipelineAsyncCallbackInfo2>::kDawnHistogramMetricsUS =
"CreateRenderPipelineUS";
template <>
-void CreatePipelineAsyncEvent<RenderPipelineBase,
- WGPUCreateRenderPipelineAsyncCallbackInfo>::AddOrGetCachedPipeline() {
+void CreatePipelineAsyncEvent<RenderPipelineBase, WGPUCreateRenderPipelineAsyncCallbackInfo2>::
+ AddOrGetCachedPipeline() {
DeviceBase* device = mPipeline->GetDevice();
auto deviceLock(device->GetScopedLock());
if (device->GetState() == DeviceBase::State::Alive) {
@@ -234,8 +234,8 @@
}
template class CreatePipelineAsyncEvent<ComputePipelineBase,
- WGPUCreateComputePipelineAsyncCallbackInfo>;
+ WGPUCreateComputePipelineAsyncCallbackInfo2>;
template class CreatePipelineAsyncEvent<RenderPipelineBase,
- WGPUCreateRenderPipelineAsyncCallbackInfo>;
+ WGPUCreateRenderPipelineAsyncCallbackInfo2>;
} // namespace dawn::native
diff --git a/src/dawn/native/CreatePipelineAsyncEvent.h b/src/dawn/native/CreatePipelineAsyncEvent.h
index b2fefa6..e2ae039 100644
--- a/src/dawn/native/CreatePipelineAsyncEvent.h
+++ b/src/dawn/native/CreatePipelineAsyncEvent.h
@@ -103,9 +103,9 @@
};
using CreateComputePipelineAsyncEvent =
- CreatePipelineAsyncEvent<ComputePipelineBase, WGPUCreateComputePipelineAsyncCallbackInfo>;
+ CreatePipelineAsyncEvent<ComputePipelineBase, WGPUCreateComputePipelineAsyncCallbackInfo2>;
using CreateRenderPipelineAsyncEvent =
- CreatePipelineAsyncEvent<RenderPipelineBase, WGPUCreateRenderPipelineAsyncCallbackInfo>;
+ CreatePipelineAsyncEvent<RenderPipelineBase, WGPUCreateRenderPipelineAsyncCallbackInfo2>;
} // namespace dawn::native
diff --git a/src/dawn/native/Device.cpp b/src/dawn/native/Device.cpp
index 8c7209f..316b6b1 100644
--- a/src/dawn/native/Device.cpp
+++ b/src/dawn/native/Device.cpp
@@ -852,21 +852,45 @@
mErrorScopeStack->Push(filter);
}
-Future DeviceBase::APIPopErrorScope(const WGPUPopErrorScopeCallbackInfo& callbackInfo) {
+void DeviceBase::APIPopErrorScope(wgpu::ErrorCallback callback, void* userdata) {
+ static wgpu::ErrorCallback kDefaultCallback = [](WGPUErrorType, WGPUStringView, void*) {};
+
+ APIPopErrorScope2({nullptr, WGPUCallbackMode_AllowProcessEvents,
+ [](WGPUPopErrorScopeStatus, WGPUErrorType type, WGPUStringView message,
+ void* callback, void* userdata) {
+ auto cb = reinterpret_cast<wgpu::ErrorCallback>(callback);
+ cb(type, message, userdata);
+ },
+ reinterpret_cast<void*>(callback != nullptr ? callback : kDefaultCallback),
+ userdata});
+}
+
+Future DeviceBase::APIPopErrorScopeF(const PopErrorScopeCallbackInfo& callbackInfo) {
+ return APIPopErrorScope2({ToAPI(callbackInfo.nextInChain), ToAPI(callbackInfo.mode),
+ [](WGPUPopErrorScopeStatus status, WGPUErrorType type,
+ WGPUStringView message, void* callback, void* userdata) {
+ auto cb = reinterpret_cast<WGPUPopErrorScopeCallback>(callback);
+ cb(status, type, message, userdata);
+ },
+ reinterpret_cast<void*>(callbackInfo.callback),
+ callbackInfo.userdata});
+}
+
+Future DeviceBase::APIPopErrorScope2(const WGPUPopErrorScopeCallbackInfo2& callbackInfo) {
struct PopErrorScopeEvent final : public EventManager::TrackedEvent {
- WGPUPopErrorScopeCallback mCallback;
+ WGPUPopErrorScopeCallback2 mCallback;
raw_ptr<void> mUserdata1;
raw_ptr<void> mUserdata2;
std::optional<ErrorScope> mScope;
- PopErrorScopeEvent(const WGPUPopErrorScopeCallbackInfo& callbackInfo,
+ PopErrorScopeEvent(const WGPUPopErrorScopeCallbackInfo2& callbackInfo,
std::optional<ErrorScope>&& scope)
: TrackedEvent(static_cast<wgpu::CallbackMode>(callbackInfo.mode),
TrackedEvent::Completed{}),
mCallback(callbackInfo.callback),
mUserdata1(callbackInfo.userdata1),
mUserdata2(callbackInfo.userdata2),
- mScope(std::move(scope)) {}
+ mScope(scope) {}
~PopErrorScopeEvent() override { EnsureComplete(EventCompletionType::Shutdown); }
@@ -1326,9 +1350,42 @@
}
return ReturnToAPI(std::move(result));
}
-Future DeviceBase::APICreateComputePipelineAsync(
+void DeviceBase::APICreateComputePipelineAsync(const ComputePipelineDescriptor* descriptor,
+ WGPUCreateComputePipelineAsyncCallback callback,
+ void* userdata) {
+ GetInstance()->EmitDeprecationWarning(
+ "Old CreateComputePipelineAsync APIs are deprecated. If using C please pass a CallbackInfo "
+ "struct that has two userdatas. Otherwise, if using C++, please use templated helpers.");
+
+ APICreateComputePipelineAsync2(
+ descriptor, {nullptr, WGPUCallbackMode_AllowProcessEvents,
+ [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline,
+ WGPUStringView message, void* callback, void* userdata) {
+ auto cb =
+ reinterpret_cast<WGPUCreateComputePipelineAsyncCallback>(callback);
+ cb(status, pipeline, message, userdata);
+ },
+ reinterpret_cast<void*>(callback), userdata});
+}
+Future DeviceBase::APICreateComputePipelineAsyncF(
const ComputePipelineDescriptor* descriptor,
- const WGPUCreateComputePipelineAsyncCallbackInfo& callbackInfo) {
+ const CreateComputePipelineAsyncCallbackInfo& callbackInfo) {
+ GetInstance()->EmitDeprecationWarning(
+ "Old CreateComputePipelineAsync APIs are deprecated. If using C please pass a CallbackInfo "
+ "struct that has two userdatas. Otherwise, if using C++, please use templated helpers.");
+ return APICreateComputePipelineAsync2(
+ descriptor, {ToAPI(callbackInfo.nextInChain), ToAPI(callbackInfo.mode),
+ [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline,
+ WGPUStringView message, void* callback, void* userdata) {
+ auto cb =
+ reinterpret_cast<WGPUCreateComputePipelineAsyncCallback>(callback);
+ cb(status, pipeline, message, userdata);
+ },
+ reinterpret_cast<void*>(callbackInfo.callback), callbackInfo.userdata});
+}
+Future DeviceBase::APICreateComputePipelineAsync2(
+ const ComputePipelineDescriptor* descriptor,
+ const WGPUCreateComputePipelineAsyncCallbackInfo2& callbackInfo) {
utils::TraceLabel label = utils::GetLabelForTrace(descriptor->label);
TRACE_EVENT1(GetPlatform(), General, "DeviceBase::APICreateComputePipelineAsync", "label",
label.label);
@@ -1395,9 +1452,42 @@
}
return ReturnToAPI(std::move(result));
}
-Future DeviceBase::APICreateRenderPipelineAsync(
+void DeviceBase::APICreateRenderPipelineAsync(const RenderPipelineDescriptor* descriptor,
+ WGPUCreateRenderPipelineAsyncCallback callback,
+ void* userdata) {
+ GetInstance()->EmitDeprecationWarning(
+ "Old CreateRenderPipelineAsync APIs are deprecated. If using C please pass a CallbackInfo "
+ "struct that has two userdatas. Otherwise, if using C++, please use templated helpers.");
+
+ APICreateRenderPipelineAsync2(
+ descriptor, {nullptr, WGPUCallbackMode_AllowProcessEvents,
+ [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline,
+ WGPUStringView message, void* callback, void* userdata) {
+ auto cb =
+ reinterpret_cast<WGPUCreateRenderPipelineAsyncCallback>(callback);
+ cb(status, pipeline, message, userdata);
+ },
+ reinterpret_cast<void*>(callback), userdata});
+}
+Future DeviceBase::APICreateRenderPipelineAsyncF(
const RenderPipelineDescriptor* descriptor,
- const WGPUCreateRenderPipelineAsyncCallbackInfo& callbackInfo) {
+ const CreateRenderPipelineAsyncCallbackInfo& callbackInfo) {
+ GetInstance()->EmitDeprecationWarning(
+ "Old CreateRenderPipelineAsync APIs are deprecated. If using C please pass a CallbackInfo "
+ "struct that has two userdatas. Otherwise, if using C++, please use templated helpers.");
+ return APICreateRenderPipelineAsync2(
+ descriptor, {ToAPI(callbackInfo.nextInChain), ToAPI(callbackInfo.mode),
+ [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline,
+ WGPUStringView message, void* callback, void* userdata) {
+ auto cb =
+ reinterpret_cast<WGPUCreateRenderPipelineAsyncCallback>(callback);
+ cb(status, pipeline, message, userdata);
+ },
+ reinterpret_cast<void*>(callbackInfo.callback), callbackInfo.userdata});
+}
+Future DeviceBase::APICreateRenderPipelineAsync2(
+ const RenderPipelineDescriptor* descriptor,
+ const WGPUCreateRenderPipelineAsyncCallbackInfo2& callbackInfo) {
utils::TraceLabel label = utils::GetLabelForTrace(descriptor->label);
TRACE_EVENT1(GetPlatform(), General, "DeviceBase::APICreateRenderPipelineAsync", "label",
label.label);
diff --git a/src/dawn/native/Device.h b/src/dawn/native/Device.h
index b6b6d8d..f0275b1 100644
--- a/src/dawn/native/Device.h
+++ b/src/dawn/native/Device.h
@@ -242,12 +242,23 @@
ComputePipelineBase* APICreateComputePipeline(const ComputePipelineDescriptor* descriptor);
PipelineLayoutBase* APICreatePipelineLayout(const PipelineLayoutDescriptor* descriptor);
QuerySetBase* APICreateQuerySet(const QuerySetDescriptor* descriptor);
- Future APICreateComputePipelineAsync(
+ void APICreateComputePipelineAsync(const ComputePipelineDescriptor* descriptor,
+ WGPUCreateComputePipelineAsyncCallback callback,
+ void* userdata);
+ Future APICreateComputePipelineAsyncF(
const ComputePipelineDescriptor* descriptor,
- const WGPUCreateComputePipelineAsyncCallbackInfo& callbackInfo);
- Future APICreateRenderPipelineAsync(
+ const CreateComputePipelineAsyncCallbackInfo& callbackInfo);
+ Future APICreateComputePipelineAsync2(
+ const ComputePipelineDescriptor* descriptor,
+ const WGPUCreateComputePipelineAsyncCallbackInfo2& callbackInfo);
+ void APICreateRenderPipelineAsync(const RenderPipelineDescriptor* descriptor,
+ WGPUCreateRenderPipelineAsyncCallback callback,
+ void* userdata);
+ Future APICreateRenderPipelineAsyncF(const RenderPipelineDescriptor* descriptor,
+ const CreateRenderPipelineAsyncCallbackInfo& callbackInfo);
+ Future APICreateRenderPipelineAsync2(
const RenderPipelineDescriptor* descriptor,
- const WGPUCreateRenderPipelineAsyncCallbackInfo& callbackInfo);
+ const WGPUCreateRenderPipelineAsyncCallbackInfo2& callbackInfo);
RenderBundleEncoder* APICreateRenderBundleEncoder(
const RenderBundleEncoderDescriptor* descriptor);
RenderPipelineBase* APICreateRenderPipeline(const RenderPipelineDescriptor* descriptor);
@@ -289,7 +300,9 @@
void APISetUncapturedErrorCallback(wgpu::ErrorCallback callback, void* userdata);
void APISetLoggingCallback(wgpu::LoggingCallback callback, void* userdata);
void APIPushErrorScope(wgpu::ErrorFilter filter);
- Future APIPopErrorScope(const WGPUPopErrorScopeCallbackInfo& callbackInfo);
+ void APIPopErrorScope(wgpu::ErrorCallback callback, void* userdata);
+ Future APIPopErrorScopeF(const PopErrorScopeCallbackInfo& callbackInfo);
+ Future APIPopErrorScope2(const WGPUPopErrorScopeCallbackInfo2& callbackInfo);
MaybeError ValidateIsAlive() const;
diff --git a/src/dawn/native/Queue.cpp b/src/dawn/native/Queue.cpp
index 5f47ca8..cc8ef36 100644
--- a/src/dawn/native/Queue.cpp
+++ b/src/dawn/native/Queue.cpp
@@ -155,6 +155,33 @@
return uploadHandle;
}
+struct SubmittedWorkDone : TrackTaskCallback {
+ SubmittedWorkDone(dawn::platform::Platform* platform,
+ WGPUQueueWorkDoneCallback callback,
+ void* userdata)
+ : TrackTaskCallback(platform), mCallback(callback), mUserdata(userdata) {}
+ ~SubmittedWorkDone() override = default;
+
+ private:
+ void FinishImpl() override {
+ DAWN_ASSERT(mCallback != nullptr);
+ DAWN_ASSERT(mSerial != kMaxExecutionSerial);
+ TRACE_EVENT1(mPlatform, General, "Queue::SubmittedWorkDone::Finished", "serial",
+ uint64_t(mSerial));
+ mCallback(WGPUQueueWorkDoneStatus_Success, mUserdata.ExtractAsDangling());
+ mCallback = nullptr;
+ }
+ void HandleDeviceLossImpl() override {
+ DAWN_ASSERT(mCallback != nullptr);
+ mCallback(WGPUQueueWorkDoneStatus_DeviceLost, mUserdata.ExtractAsDangling());
+ mCallback = nullptr;
+ }
+ void HandleShutDownImpl() override { HandleDeviceLossImpl(); }
+
+ WGPUQueueWorkDoneCallback mCallback = nullptr;
+ raw_ptr<void> mUserdata;
+};
+
class ErrorQueue : public QueueBase {
public:
explicit ErrorQueue(DeviceBase* device, StringView label)
@@ -230,15 +257,55 @@
ityp::span<uint32_t, CommandBufferBase* const>(commands, commandCount));
}
-Future QueueBase::APIOnSubmittedWorkDone(const WGPUQueueWorkDoneCallbackInfo& callbackInfo) {
+void QueueBase::APIOnSubmittedWorkDone(WGPUQueueWorkDoneCallback callback, void* userdata) {
+ GetInstance()->EmitDeprecationWarning(
+ "Old OnSubmittedWorkDone APIs are deprecated. If using C please pass a CallbackInfo "
+ "struct that has two userdatas. Otherwise, if using C++, please use templated helpers.");
+
+ // The error status depends on the type of error so we let the validation function choose it
+ wgpu::QueueWorkDoneStatus status;
+ if (GetDevice()->ConsumedError(ValidateOnSubmittedWorkDone(&status))) {
+ GetDevice()->GetCallbackTaskManager()->AddCallbackTask(
+ [callback, status, userdata] { callback(ToAPI(status), userdata); });
+ return;
+ }
+
+ std::unique_ptr<SubmittedWorkDone> task =
+ std::make_unique<SubmittedWorkDone>(GetDevice()->GetPlatform(), callback, userdata);
+
+ // Technically we only need to wait for previously submitted work but OnSubmittedWorkDone is
+ // also used to make sure ALL queue work is finished in tests, so we also wait for pending
+ // commands (this is non-observable outside of tests so it's ok to do deviate a bit from the
+ // spec).
+ TrackTaskAfterEventualFlush(std::move(task));
+
+ TRACE_EVENT1(GetDevice()->GetPlatform(), General, "Queue::APIOnSubmittedWorkDone", "serial",
+ uint64_t(GetPendingCommandSerial()));
+}
+
+Future QueueBase::APIOnSubmittedWorkDoneF(const QueueWorkDoneCallbackInfo& callbackInfo) {
+ GetInstance()->EmitDeprecationWarning(
+ "Old OnSubmittedWorkDone APIs are deprecated. If using C please pass a CallbackInfo "
+ "struct that has two userdatas. Otherwise, if using C++, please use templated helpers.");
+
+ return APIOnSubmittedWorkDone2(
+ {ToAPI(callbackInfo.nextInChain), ToAPI(callbackInfo.mode),
+ [](WGPUQueueWorkDoneStatus status, void* callback, void* userdata) {
+ auto cb = reinterpret_cast<WGPUQueueWorkDoneCallback>(callback);
+ cb(status, userdata);
+ },
+ reinterpret_cast<void*>(callbackInfo.callback), callbackInfo.userdata});
+}
+
+Future QueueBase::APIOnSubmittedWorkDone2(const WGPUQueueWorkDoneCallbackInfo2& callbackInfo) {
struct WorkDoneEvent final : public EventManager::TrackedEvent {
std::optional<WGPUQueueWorkDoneStatus> mEarlyStatus;
- WGPUQueueWorkDoneCallback mCallback;
+ WGPUQueueWorkDoneCallback2 mCallback;
raw_ptr<void> mUserdata1;
raw_ptr<void> mUserdata2;
// Create an event backed by the given queue execution serial.
- WorkDoneEvent(const WGPUQueueWorkDoneCallbackInfo& callbackInfo,
+ WorkDoneEvent(const WGPUQueueWorkDoneCallbackInfo2& callbackInfo,
QueueBase* queue,
ExecutionSerial serial)
: TrackedEvent(static_cast<wgpu::CallbackMode>(callbackInfo.mode), queue, serial),
@@ -247,7 +314,7 @@
mUserdata2(callbackInfo.userdata2) {}
// Create an event that's ready at creation (for errors, etc.)
- WorkDoneEvent(const WGPUQueueWorkDoneCallbackInfo& callbackInfo,
+ WorkDoneEvent(const WGPUQueueWorkDoneCallbackInfo2& callbackInfo,
QueueBase* queue,
wgpu::QueueWorkDoneStatus earlyStatus)
: TrackedEvent(static_cast<wgpu::CallbackMode>(callbackInfo.mode),
@@ -283,8 +350,15 @@
// re-entrancy.
auto deviceLock(GetDevice()->GetScopedLock());
- wgpu::QueueWorkDoneStatus validationEarlyStatus = wgpu::QueueWorkDoneStatus::Success;
+ wgpu::QueueWorkDoneStatus validationEarlyStatus;
if (GetDevice()->ConsumedError(ValidateOnSubmittedWorkDone(&validationEarlyStatus))) {
+ // TODO(crbug.com/dawn/2021): This is here to pretend that things succeed when the
+ // device is lost. When the old OnSubmittedWorkDone is removed then we can update
+ // ValidateOnSubmittedWorkDone to just return the correct thing here.
+ if (validationEarlyStatus == wgpu::QueueWorkDoneStatus::DeviceLost) {
+ validationEarlyStatus = wgpu::QueueWorkDoneStatus::Success;
+ }
+
// Note: if the callback is spontaneous, it'll get called in here.
event = AcquireRef(new WorkDoneEvent(callbackInfo, this, validationEarlyStatus));
} else {
@@ -567,6 +641,7 @@
}
MaybeError QueueBase::ValidateOnSubmittedWorkDone(wgpu::QueueWorkDoneStatus* status) const {
+ *status = wgpu::QueueWorkDoneStatus::DeviceLost;
DAWN_TRY(GetDevice()->ValidateIsAlive());
*status = wgpu::QueueWorkDoneStatus::Error;
diff --git a/src/dawn/native/Queue.h b/src/dawn/native/Queue.h
index 71dcdcd..36ec006 100644
--- a/src/dawn/native/Queue.h
+++ b/src/dawn/native/Queue.h
@@ -73,7 +73,9 @@
// Dawn API
void APISubmit(uint32_t commandCount, CommandBufferBase* const* commands);
- Future APIOnSubmittedWorkDone(const WGPUQueueWorkDoneCallbackInfo& callbackInfo);
+ void APIOnSubmittedWorkDone(WGPUQueueWorkDoneCallback callback, void* userdata);
+ Future APIOnSubmittedWorkDoneF(const QueueWorkDoneCallbackInfo& callbackInfo);
+ Future APIOnSubmittedWorkDone2(const WGPUQueueWorkDoneCallbackInfo2& callbackInfo);
void APIWriteBuffer(BufferBase* buffer, uint64_t bufferOffset, const void* data, size_t size);
void APIWriteTexture(const ImageCopyTexture* destination,
const void* data,
diff --git a/src/dawn/native/ShaderModule.cpp b/src/dawn/native/ShaderModule.cpp
index 9d47730..97b3129 100644
--- a/src/dawn/native/ShaderModule.cpp
+++ b/src/dawn/native/ShaderModule.cpp
@@ -1584,17 +1584,58 @@
return mTintData.Use([&](auto tintData) { return tintData->tintProgramRecreateCount; });
}
-Future ShaderModuleBase::APIGetCompilationInfo(
- const WGPUCompilationInfoCallbackInfo& callbackInfo) {
+namespace {
+
+void DefaultGetCompilationInfoCallback(WGPUCompilationInfoRequestStatus status,
+ const WGPUCompilationInfo* compilationInfo,
+ void* callback,
+ void* userdata) {
+ if (callback == nullptr) {
+ DAWN_ASSERT(userdata == nullptr);
+ return;
+ }
+ auto cb = reinterpret_cast<WGPUCompilationInfoCallback>(callback);
+ cb(status, compilationInfo, userdata);
+}
+
+} // anonymous namespace
+
+void ShaderModuleBase::APIGetCompilationInfo(wgpu::CompilationInfoCallback callback,
+ void* userdata) {
+ GetInstance()->EmitDeprecationWarning(
+ "Old GetCompilationInfo APIs are deprecated. If using C please pass a CallbackInfo struct "
+ "that has two userdatas. Otherwise, if using C++, please use templated helpers.");
+
+ if (callback == nullptr) {
+ return;
+ }
+ APIGetCompilationInfo2({nullptr, WGPUCallbackMode_AllowSpontaneous,
+ &DefaultGetCompilationInfoCallback, reinterpret_cast<void*>(callback),
+ userdata});
+}
+
+Future ShaderModuleBase::APIGetCompilationInfoF(const CompilationInfoCallbackInfo& callbackInfo) {
+ GetInstance()->EmitDeprecationWarning(
+ "Old GetCompilationInfo APIs are deprecated. If using C please pass a CallbackInfo struct "
+ "that has two userdatas. Otherwise, if using C++, please use templated helpers.");
+
+ return APIGetCompilationInfo2({ToAPI(callbackInfo.nextInChain), ToAPI(callbackInfo.mode),
+ &DefaultGetCompilationInfoCallback,
+ reinterpret_cast<void*>(callbackInfo.callback),
+ callbackInfo.userdata});
+}
+
+Future ShaderModuleBase::APIGetCompilationInfo2(
+ const WGPUCompilationInfoCallbackInfo2& callbackInfo) {
struct CompilationInfoEvent final : public EventManager::TrackedEvent {
- WGPUCompilationInfoCallback mCallback;
+ WGPUCompilationInfoCallback2 mCallback;
raw_ptr<void> mUserdata1;
raw_ptr<void> mUserdata2;
// Need to keep a Ref of the compilation messages in case the ShaderModule goes away before
// the callback happens.
Ref<ShaderModuleBase> mShaderModule;
- CompilationInfoEvent(const WGPUCompilationInfoCallbackInfo& callbackInfo,
+ CompilationInfoEvent(const WGPUCompilationInfoCallbackInfo2& callbackInfo,
Ref<ShaderModuleBase> shaderModule)
: TrackedEvent(static_cast<wgpu::CallbackMode>(callbackInfo.mode),
TrackedEvent::Completed{}),
diff --git a/src/dawn/native/ShaderModule.h b/src/dawn/native/ShaderModule.h
index 9ae9217..3d371c8 100644
--- a/src/dawn/native/ShaderModule.h
+++ b/src/dawn/native/ShaderModule.h
@@ -348,7 +348,9 @@
Ref<TintProgram> GetTintProgramForTesting() const;
int GetTintProgramRecreateCountForTesting() const;
- Future APIGetCompilationInfo(const WGPUCompilationInfoCallbackInfo& callbackInfo);
+ void APIGetCompilationInfo(wgpu::CompilationInfoCallback callback, void* userdata);
+ Future APIGetCompilationInfoF(const CompilationInfoCallbackInfo& callbackInfo);
+ Future APIGetCompilationInfo2(const WGPUCompilationInfoCallbackInfo2& callbackInfo);
void InjectCompilationMessages(std::unique_ptr<OwnedCompilationMessages> compilationMessages);
OwnedCompilationMessages* GetCompilationMessages() const;
diff --git a/src/dawn/tests/end2end/BufferTests.cpp b/src/dawn/tests/end2end/BufferTests.cpp
index bfa76f1..5f79c9a 100644
--- a/src/dawn/tests/end2end/BufferTests.cpp
+++ b/src/dawn/tests/end2end/BufferTests.cpp
@@ -48,7 +48,7 @@
using testing::MockCppCallback;
using testing::StrictMock;
-using MockMapAsyncCallback = MockCppCallback<wgpu::BufferMapCallback<void>*>;
+using MockMapAsyncCallback = MockCppCallback<wgpu::BufferMapCallback2<void>*>;
using FutureCallbackMode = wgpu::CallbackMode;
DAWN_TEST_PARAM_STRUCT(BufferMappingTestParams, FutureCallbackMode);
@@ -66,7 +66,7 @@
wgpu::MapMode mode,
size_t offset,
size_t size,
- wgpu::BufferMapCallback<> cb = nullptr) {
+ wgpu::BufferMapCallback2<> cb = nullptr) {
wgpu::Future future;
if (cb) {
diff --git a/src/dawn/tests/end2end/DeviceLostTests.cpp b/src/dawn/tests/end2end/DeviceLostTests.cpp
index 6d0b5f7..ddb6eb3 100644
--- a/src/dawn/tests/end2end/DeviceLostTests.cpp
+++ b/src/dawn/tests/end2end/DeviceLostTests.cpp
@@ -44,8 +44,10 @@
using testing::HasSubstr;
using testing::MockCppCallback;
-using MockMapAsyncCallback = MockCppCallback<wgpu::BufferMapCallback<void>*>;
-using MockQueueWorkDoneCallback = MockCppCallback<wgpu::QueueWorkDoneCallback<void>*>;
+using MockMapAsyncCallback = MockCppCallback<void (*)(wgpu::MapAsyncStatus, wgpu::StringView)>;
+using MockQueueWorkDoneCallback = MockCppCallback<void (*)(wgpu::QueueWorkDoneStatus)>;
+
+static const int fakeUserData = 0;
class DeviceLostTest : public DawnTest {
protected:
@@ -61,6 +63,11 @@
}
}
+ static void MapFailCallback(WGPUBufferMapAsyncStatus status, void* userdata) {
+ EXPECT_EQ(WGPUBufferMapAsyncStatus_DeviceLost, status);
+ EXPECT_EQ(&fakeUserData, userdata);
+ }
+
template <typename T>
void ExpectObjectIsError(const T& object) {
EXPECT_TRUE(dawn::native::CheckIsErrorForTesting(object.Get()));
diff --git a/src/dawn/tests/unittests/native/AllowedErrorTests.cpp b/src/dawn/tests/unittests/native/AllowedErrorTests.cpp
index b9ac911..dbbc373 100644
--- a/src/dawn/tests/unittests/native/AllowedErrorTests.cpp
+++ b/src/dawn/tests/unittests/native/AllowedErrorTests.cpp
@@ -59,9 +59,9 @@
using ::testing::Test;
using MockComputePipelineAsyncCallback =
- MockCppCallback<wgpu::CreateComputePipelineAsyncCallback<void>*>;
+ MockCppCallback<wgpu::CreateComputePipelineAsyncCallback2<void>*>;
using MockRenderPipelineAsyncCallback =
- MockCppCallback<wgpu::CreateRenderPipelineAsyncCallback<void>*>;
+ MockCppCallback<wgpu::CreateRenderPipelineAsyncCallback2<void>*>;
static constexpr char kOomErrorMessage[] = "Out of memory error";
static constexpr char kInternalErrorMessage[] = "Internal error";
diff --git a/src/dawn/tests/unittests/wire/WireBufferMappingTests.cpp b/src/dawn/tests/unittests/wire/WireBufferMappingTests.cpp
index f11b748..d301be3 100644
--- a/src/dawn/tests/unittests/wire/WireBufferMappingTests.cpp
+++ b/src/dawn/tests/unittests/wire/WireBufferMappingTests.cpp
@@ -69,7 +69,7 @@
DAWN_WIRE_FUTURE_TEST_PARAM_STRUCT(WireBufferParam, MapMode);
using WireBufferMappingTestBase =
- WireFutureTestWithParams<wgpu::BufferMapCallback<void>*, WireBufferParam>;
+ WireFutureTestWithParams<wgpu::BufferMapCallback2<void>*, WireBufferParam>;
// General mapping tests that either do not care about the specific mapping mode, or apply to both.
class WireBufferMappingTests : public WireBufferMappingTestBase {
@@ -146,10 +146,10 @@
uint32_t bufferContent = 31337;
EXPECT_CALL(
- api, OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
+ api, OnBufferMapAsync2(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
- kEmptyOutputStringView);
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Success,
+ kEmptyOutputStringView);
}));
ExpectMappedRangeCall(kBufferSize, &bufferContent);
addExpectations();
@@ -188,10 +188,10 @@
MapAsync(mapMode, 0, kBufferSize);
EXPECT_CALL(
- api, OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
+ api, OnBufferMapAsync2(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Error,
- ToOutputStringView("Validation error"));
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Error,
+ ToOutputStringView("Validation error"));
}));
// Ensure that the server had a chance to respond if relevant.
@@ -232,10 +232,10 @@
uint32_t bufferContent = 31337;
EXPECT_CALL(
- api, OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
+ api, OnBufferMapAsync2(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
- kEmptyOutputStringView);
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Success,
+ kEmptyOutputStringView);
}));
ExpectMappedRangeCall(kBufferSize, &bufferContent);
@@ -275,10 +275,10 @@
MapAsync(mapMode, 0, kBufferSize);
EXPECT_CALL(api,
- OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
+ OnBufferMapAsync2(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Error,
- ToOutputStringView("Validation error"));
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Error,
+ ToOutputStringView("Validation error"));
}));
FlushClient();
@@ -403,10 +403,10 @@
MapAsync(wgpu::MapMode::Read, 0, kBufferSize);
uint32_t bufferContent = 31337;
- EXPECT_CALL(api, OnBufferMapAsync(apiBuffer, WGPUMapMode_Read, 0, kBufferSize, _))
+ EXPECT_CALL(api, OnBufferMapAsync2(apiBuffer, WGPUMapMode_Read, 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
- kEmptyOutputStringView);
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Success,
+ kEmptyOutputStringView);
}));
EXPECT_CALL(api, BufferGetConstMappedRange(apiBuffer, 0, kBufferSize))
.WillOnce(Return(&bufferContent));
@@ -433,10 +433,10 @@
MapAsync(wgpu::MapMode::Read, 0, kBufferSize);
uint32_t bufferContent = 31337;
- EXPECT_CALL(api, OnBufferMapAsync(apiBuffer, WGPUMapMode_Read, 0, kBufferSize, _))
+ EXPECT_CALL(api, OnBufferMapAsync2(apiBuffer, WGPUMapMode_Read, 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
- kEmptyOutputStringView);
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Success,
+ kEmptyOutputStringView);
}));
EXPECT_CALL(api, BufferGetConstMappedRange(apiBuffer, 0, kBufferSize))
.WillOnce(Return(&bufferContent));
@@ -452,10 +452,10 @@
// Map failure while the buffer is already mapped
MapAsync(wgpu::MapMode::Read, 0, kBufferSize);
- EXPECT_CALL(api, OnBufferMapAsync(apiBuffer, WGPUMapMode_Read, 0, kBufferSize, _))
+ EXPECT_CALL(api, OnBufferMapAsync2(apiBuffer, WGPUMapMode_Read, 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Error,
- ToOutputStringView("Already mapped"));
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Error,
+ ToOutputStringView("Already mapped"));
}));
FlushClient();
@@ -489,10 +489,10 @@
uint32_t serverBufferContent = 31337;
uint32_t updatedContent = 4242;
- EXPECT_CALL(api, OnBufferMapAsync(apiBuffer, WGPUMapMode_Write, 0, kBufferSize, _))
+ EXPECT_CALL(api, OnBufferMapAsync2(apiBuffer, WGPUMapMode_Write, 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
- kEmptyOutputStringView);
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Success,
+ kEmptyOutputStringView);
}));
EXPECT_CALL(api, BufferGetMappedRange(apiBuffer, 0, kBufferSize))
.WillOnce(Return(&serverBufferContent));
@@ -527,10 +527,10 @@
MapAsync(wgpu::MapMode::Write, 0, kBufferSize);
uint32_t bufferContent = 31337;
- EXPECT_CALL(api, OnBufferMapAsync(apiBuffer, WGPUMapMode_Write, 0, kBufferSize, _))
+ EXPECT_CALL(api, OnBufferMapAsync2(apiBuffer, WGPUMapMode_Write, 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
- kEmptyOutputStringView);
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Success,
+ kEmptyOutputStringView);
}));
EXPECT_CALL(api, BufferGetMappedRange(apiBuffer, 0, kBufferSize))
.WillOnce(Return(&bufferContent));
@@ -545,10 +545,10 @@
// Map failure while the buffer is already mapped
MapAsync(wgpu::MapMode::Write, 0, kBufferSize);
- EXPECT_CALL(api, OnBufferMapAsync(apiBuffer, WGPUMapMode_Write, 0, kBufferSize, _))
+ EXPECT_CALL(api, OnBufferMapAsync2(apiBuffer, WGPUMapMode_Write, 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Error,
- ToOutputStringView("Already mapped"));
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Error,
+ ToOutputStringView("Already mapped"));
}));
FlushClient();
@@ -630,10 +630,10 @@
MapAsync(wgpu::MapMode::Write, 0, kBufferSize);
- EXPECT_CALL(api, OnBufferMapAsync(apiBuffer, WGPUMapMode_Write, 0, kBufferSize, _))
+ EXPECT_CALL(api, OnBufferMapAsync2(apiBuffer, WGPUMapMode_Write, 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
- kEmptyOutputStringView);
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Success,
+ kEmptyOutputStringView);
}));
EXPECT_CALL(api, BufferGetMappedRange(apiBuffer, 0, kBufferSize))
.WillOnce(Return(&apiBufferData));
@@ -664,10 +664,10 @@
// Note that the validation logic is entirely on the native side so we inject the validation
// error here and flush the server response to mock the expected behavior.
- EXPECT_CALL(api, OnBufferMapAsync(apiBuffer, WGPUMapMode_Write, 0, kBufferSize, _))
+ EXPECT_CALL(api, OnBufferMapAsync2(apiBuffer, WGPUMapMode_Write, 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Error,
- ToOutputStringView("Already mapped"));
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Error,
+ ToOutputStringView("Already mapped"));
}));
FlushClient();
@@ -735,10 +735,10 @@
uint32_t bufferContent = 0;
EXPECT_CALL(api,
- OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
+ OnBufferMapAsync2(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
- kEmptyOutputStringView);
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Success,
+ kEmptyOutputStringView);
}));
ExpectMappedRangeCall(kBufferSize, &bufferContent);
@@ -771,10 +771,10 @@
// Calls for the first successful map.
uint32_t bufferContent = 0;
EXPECT_CALL(api,
- OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
+ OnBufferMapAsync2(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
- kEmptyOutputStringView);
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Success,
+ kEmptyOutputStringView);
}));
ExpectMappedRangeCall(kBufferSize, &bufferContent);
@@ -823,10 +823,10 @@
ASSERT_EQ(buffer.GetMapState(), wgpu::BufferMapState::Unmapped);
EXPECT_CALL(
- api, OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
+ api, OnBufferMapAsync2(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
- kEmptyOutputStringView);
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Success,
+ kEmptyOutputStringView);
}));
ExpectMappedRangeCall(kBufferSize, &bufferContent);
MapAsync(mapMode, 0, kBufferSize);
@@ -861,10 +861,10 @@
// Server-side error case
{
EXPECT_CALL(
- api, OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
+ api, OnBufferMapAsync2(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Error,
- ToOutputStringView("Error"));
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Error,
+ ToOutputStringView("Error"));
}));
// Map state should initially be unmapped.
@@ -901,10 +901,10 @@
uint32_t bufferContent = 0;
EXPECT_CALL(api,
- OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
+ OnBufferMapAsync2(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
- kEmptyOutputStringView);
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Success,
+ kEmptyOutputStringView);
}));
ExpectMappedRangeCall(kBufferSize, &bufferContent);
@@ -932,10 +932,10 @@
uint32_t bufferContent = 0;
EXPECT_CALL(api,
- OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
+ OnBufferMapAsync2(apiBuffer, static_cast<WGPUMapMode>(mapMode), 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
- kEmptyOutputStringView);
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Success,
+ kEmptyOutputStringView);
}));
ExpectMappedRangeCall(kBufferSize, &bufferContent);
diff --git a/src/dawn/tests/unittests/wire/WireCreatePipelineAsyncTests.cpp b/src/dawn/tests/unittests/wire/WireCreatePipelineAsyncTests.cpp
index 9542443..396345c 100644
--- a/src/dawn/tests/unittests/wire/WireCreatePipelineAsyncTests.cpp
+++ b/src/dawn/tests/unittests/wire/WireCreatePipelineAsyncTests.cpp
@@ -51,7 +51,7 @@
using testing::SizedString;
using WireCreateComputePipelineAsyncTestBase =
- WireFutureTest<wgpu::CreateComputePipelineAsyncCallback<void>*>;
+ WireFutureTest<wgpu::CreateComputePipelineAsyncCallback2<void>*>;
class WireCreateComputePipelineAsyncTest : public WireCreateComputePipelineAsyncTestBase {
protected:
void CreateComputePipelineAsync(wgpu::ComputePipelineDescriptor const* desc) {
@@ -95,7 +95,7 @@
};
using WireCreateRenderPipelineAsyncTestBase =
- WireFutureTest<wgpu::CreateRenderPipelineAsyncCallback<void>*>;
+ WireFutureTest<wgpu::CreateRenderPipelineAsyncCallback2<void>*>;
class WireCreateRenderPipelineAsyncTest : public WireCreateRenderPipelineAsyncTestBase {
protected:
void CreateRenderPipelineAsync(wgpu::RenderPipelineDescriptor const* desc) {
@@ -149,11 +149,11 @@
TEST_P(WireCreateComputePipelineAsyncTest, CreateSuccess) {
CreateComputePipelineAsync(&mDescriptor);
- EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _))
+ EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync2(apiDevice, _, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallDeviceCreateComputePipelineAsyncCallback(apiDevice,
- WGPUCreatePipelineAsyncStatus_Success,
- apiPipeline, kEmptyOutputStringView);
+ api.CallDeviceCreateComputePipelineAsync2Callback(apiDevice,
+ WGPUCreatePipelineAsyncStatus_Success,
+ apiPipeline, kEmptyOutputStringView);
}));
FlushClient();
@@ -171,11 +171,11 @@
TEST_P(WireCreateRenderPipelineAsyncTest, CreateSuccess) {
CreateRenderPipelineAsync(&mDescriptor);
- EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _))
+ EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync2(apiDevice, _, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallDeviceCreateRenderPipelineAsyncCallback(apiDevice,
- WGPUCreatePipelineAsyncStatus_Success,
- apiPipeline, kEmptyOutputStringView);
+ api.CallDeviceCreateRenderPipelineAsync2Callback(apiDevice,
+ WGPUCreatePipelineAsyncStatus_Success,
+ apiPipeline, kEmptyOutputStringView);
}));
FlushClient();
@@ -193,9 +193,9 @@
TEST_P(WireCreateComputePipelineAsyncTest, CreateError) {
CreateComputePipelineAsync(&mDescriptor);
- EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _))
+ EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync2(apiDevice, _, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallDeviceCreateComputePipelineAsyncCallback(
+ api.CallDeviceCreateComputePipelineAsync2Callback(
apiDevice, WGPUCreatePipelineAsyncStatus_ValidationError, nullptr,
ToOutputStringView("Some error message"));
}));
@@ -215,9 +215,9 @@
TEST_P(WireCreateRenderPipelineAsyncTest, CreateError) {
CreateRenderPipelineAsync(&mDescriptor);
- EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _))
+ EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync2(apiDevice, _, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallDeviceCreateRenderPipelineAsyncCallback(
+ api.CallDeviceCreateRenderPipelineAsync2Callback(
apiDevice, WGPUCreatePipelineAsyncStatus_ValidationError, nullptr,
ToOutputStringView("Some error message"));
}));
@@ -238,11 +238,11 @@
TEST_P(WireCreateComputePipelineAsyncTest, CreateThenDisconnect) {
CreateComputePipelineAsync(&mDescriptor);
- EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _))
+ EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync2(apiDevice, _, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallDeviceCreateComputePipelineAsyncCallback(apiDevice,
- WGPUCreatePipelineAsyncStatus_Success,
- apiPipeline, kEmptyOutputStringView);
+ api.CallDeviceCreateComputePipelineAsync2Callback(apiDevice,
+ WGPUCreatePipelineAsyncStatus_Success,
+ apiPipeline, kEmptyOutputStringView);
}));
FlushClient();
@@ -260,11 +260,11 @@
TEST_P(WireCreateRenderPipelineAsyncTest, CreateThenDisconnect) {
CreateRenderPipelineAsync(&mDescriptor);
- EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _))
+ EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync2(apiDevice, _, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallDeviceCreateRenderPipelineAsyncCallback(apiDevice,
- WGPUCreatePipelineAsyncStatus_Success,
- apiPipeline, kEmptyOutputStringView);
+ api.CallDeviceCreateRenderPipelineAsync2Callback(apiDevice,
+ WGPUCreatePipelineAsyncStatus_Success,
+ apiPipeline, kEmptyOutputStringView);
}));
FlushClient();
diff --git a/src/dawn/tests/unittests/wire/WireErrorCallbackTests.cpp b/src/dawn/tests/unittests/wire/WireErrorCallbackTests.cpp
index eb6a692..4fc1c3d 100644
--- a/src/dawn/tests/unittests/wire/WireErrorCallbackTests.cpp
+++ b/src/dawn/tests/unittests/wire/WireErrorCallbackTests.cpp
@@ -126,7 +126,7 @@
FlushServer();
}
-using WirePopErrorScopeCallbackTestBase = WireFutureTest<wgpu::PopErrorScopeCallback<void>*>;
+using WirePopErrorScopeCallbackTestBase = WireFutureTest<wgpu::PopErrorScopeCallback2<void>*>;
class WirePopErrorScopeCallbackTests : public WirePopErrorScopeCallbackTestBase {
protected:
void PopErrorScope() {
@@ -153,10 +153,10 @@
for (const auto& [type, filter] : kErrorTypeAndFilters) {
PushErrorScope(filter);
PopErrorScope();
- EXPECT_CALL(api, OnDevicePopErrorScope(apiDevice, _)).WillOnce([&] {
- api.CallDevicePopErrorScopeCallback(apiDevice, WGPUPopErrorScopeStatus_Success,
- static_cast<WGPUErrorType>(type),
- ToOutputStringView("Some error message"));
+ EXPECT_CALL(api, OnDevicePopErrorScope2(apiDevice, _)).WillOnce([&] {
+ api.CallDevicePopErrorScope2Callback(apiDevice, WGPUPopErrorScopeStatus_Success,
+ static_cast<WGPUErrorType>(type),
+ ToOutputStringView("Some error message"));
});
FlushClient();
@@ -176,7 +176,7 @@
PushErrorScope(wgpu::ErrorFilter::Validation);
PopErrorScope();
- EXPECT_CALL(api, OnDevicePopErrorScope(apiDevice, _)).Times(1);
+ EXPECT_CALL(api, OnDevicePopErrorScope2(apiDevice, _)).Times(1);
FlushClient();
FlushFutures();
@@ -198,10 +198,10 @@
PushErrorScope(wgpu::ErrorFilter::Validation);
PopErrorScope();
- EXPECT_CALL(api, OnDevicePopErrorScope(apiDevice, _)).WillOnce(InvokeWithoutArgs([&] {
- api.CallDevicePopErrorScopeCallback(apiDevice, WGPUPopErrorScopeStatus_Success,
- WGPUErrorType_Validation,
- ToOutputStringView("Some error message"));
+ EXPECT_CALL(api, OnDevicePopErrorScope2(apiDevice, _)).WillOnce(InvokeWithoutArgs([&] {
+ api.CallDevicePopErrorScope2Callback(apiDevice, WGPUPopErrorScopeStatus_Success,
+ WGPUErrorType_Validation,
+ ToOutputStringView("Some error message"));
}));
FlushClient();
@@ -219,10 +219,10 @@
TEST_P(WirePopErrorScopeCallbackTests, EmptyStack) {
PopErrorScope();
- EXPECT_CALL(api, OnDevicePopErrorScope(apiDevice, _)).WillOnce(InvokeWithoutArgs([&] {
- api.CallDevicePopErrorScopeCallback(apiDevice, WGPUPopErrorScopeStatus_Success,
- WGPUErrorType_NoError,
- ToOutputStringView("No error scopes to pop"));
+ EXPECT_CALL(api, OnDevicePopErrorScope2(apiDevice, _)).WillOnce(InvokeWithoutArgs([&] {
+ api.CallDevicePopErrorScope2Callback(apiDevice, WGPUPopErrorScopeStatus_Success,
+ WGPUErrorType_NoError,
+ ToOutputStringView("No error scopes to pop"));
}));
FlushClient();
diff --git a/src/dawn/tests/unittests/wire/WireMemoryTransferServiceTests.cpp b/src/dawn/tests/unittests/wire/WireMemoryTransferServiceTests.cpp
index b5b962b..d80b89b 100644
--- a/src/dawn/tests/unittests/wire/WireMemoryTransferServiceTests.cpp
+++ b/src/dawn/tests/unittests/wire/WireMemoryTransferServiceTests.cpp
@@ -340,10 +340,10 @@
// Mode independent expectations.
EXPECT_CALL(api,
- OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mode), 0, kBufferSize, _))
+ OnBufferMapAsync2(apiBuffer, static_cast<WGPUMapMode>(mode), 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
- kEmptyOutputStringView);
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Success,
+ kEmptyOutputStringView);
}));
EXPECT_CALL(mMapAsyncCb, Call(wgpu::MapAsyncStatus::Success, _)).Times(1);
@@ -471,7 +471,7 @@
uint32_t mSerializeCreateInfo = kDataGenerator++;
static constexpr size_t kDataSize = sizeof(uint32_t);
- StrictMock<MockCppCallback<wgpu::BufferMapCallback<void>*>> mMapAsyncCb;
+ StrictMock<MockCppCallback<wgpu::BufferMapCallback2<void>*>> mMapAsyncCb;
StrictMock<wire::server::MockMemoryTransferService> mServerMTS;
StrictMock<wire::client::MockMemoryTransferService> mClientMTS;
@@ -614,10 +614,11 @@
mMapAsyncCb.Callback());
// Make the server respond to the callback with an error.
- EXPECT_CALL(api, OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mode), 0, kBufferSize, _))
+ EXPECT_CALL(api,
+ OnBufferMapAsync2(apiBuffer, static_cast<WGPUMapMode>(mode), 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Error,
- ToOutputStringView("Validation error"));
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Error,
+ ToOutputStringView("Validation error"));
}));
FlushClient();
@@ -657,10 +658,11 @@
}
// Set mode independent expectations for the map async call now.
- EXPECT_CALL(api, OnBufferMapAsync(apiBuffer, static_cast<WGPUMapMode>(mode), 0, kBufferSize, _))
+ EXPECT_CALL(api,
+ OnBufferMapAsync2(apiBuffer, static_cast<WGPUMapMode>(mode), 0, kBufferSize, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallBufferMapAsyncCallback(apiBuffer, WGPUMapAsyncStatus_Success,
- kEmptyOutputStringView);
+ api.CallBufferMapAsync2Callback(apiBuffer, WGPUMapAsyncStatus_Success,
+ kEmptyOutputStringView);
}));
switch (mode) {
diff --git a/src/dawn/tests/unittests/wire/WireQueueTests.cpp b/src/dawn/tests/unittests/wire/WireQueueTests.cpp
index b1a2477..fa3d1db 100644
--- a/src/dawn/tests/unittests/wire/WireQueueTests.cpp
+++ b/src/dawn/tests/unittests/wire/WireQueueTests.cpp
@@ -39,7 +39,7 @@
using testing::InvokeWithoutArgs;
using testing::Return;
-using WireQueueTestBase = WireFutureTest<wgpu::QueueWorkDoneCallback<void>*>;
+using WireQueueTestBase = WireFutureTest<wgpu::QueueWorkDoneCallback2<void>*>;
class WireQueueTests : public WireQueueTestBase {
protected:
void OnSubmittedWorkDone() {
@@ -54,8 +54,8 @@
TEST_P(WireQueueTests, OnSubmittedWorkDoneSuccess) {
OnSubmittedWorkDone();
- EXPECT_CALL(api, OnQueueOnSubmittedWorkDone(apiQueue, _)).WillOnce(InvokeWithoutArgs([&] {
- api.CallQueueOnSubmittedWorkDoneCallback(apiQueue, WGPUQueueWorkDoneStatus_Success);
+ EXPECT_CALL(api, OnQueueOnSubmittedWorkDone2(apiQueue, _)).WillOnce(InvokeWithoutArgs([&] {
+ api.CallQueueOnSubmittedWorkDone2Callback(apiQueue, WGPUQueueWorkDoneStatus_Success);
}));
FlushClient();
FlushFutures();
@@ -71,8 +71,8 @@
TEST_P(WireQueueTests, OnSubmittedWorkDoneError) {
OnSubmittedWorkDone();
- EXPECT_CALL(api, OnQueueOnSubmittedWorkDone(apiQueue, _)).WillOnce(InvokeWithoutArgs([&] {
- api.CallQueueOnSubmittedWorkDoneCallback(apiQueue, WGPUQueueWorkDoneStatus_Error);
+ EXPECT_CALL(api, OnQueueOnSubmittedWorkDone2(apiQueue, _)).WillOnce(InvokeWithoutArgs([&] {
+ api.CallQueueOnSubmittedWorkDone2Callback(apiQueue, WGPUQueueWorkDoneStatus_Error);
}));
FlushClient();
FlushFutures();
@@ -93,8 +93,8 @@
OnSubmittedWorkDone();
- EXPECT_CALL(api, OnQueueOnSubmittedWorkDone(apiQueue, _)).WillOnce(InvokeWithoutArgs([&] {
- api.CallQueueOnSubmittedWorkDoneCallback(apiQueue, WGPUQueueWorkDoneStatus_Error);
+ EXPECT_CALL(api, OnQueueOnSubmittedWorkDone2(apiQueue, _)).WillOnce(InvokeWithoutArgs([&] {
+ api.CallQueueOnSubmittedWorkDone2Callback(apiQueue, WGPUQueueWorkDoneStatus_Error);
}));
FlushClient();
FlushFutures();
@@ -112,8 +112,8 @@
TEST_P(WireQueueTests, OnSubmittedWorkDoneBeforeDisconnectBeforeReply) {
OnSubmittedWorkDone();
- EXPECT_CALL(api, OnQueueOnSubmittedWorkDone(apiQueue, _)).WillOnce(InvokeWithoutArgs([&] {
- api.CallQueueOnSubmittedWorkDoneCallback(apiQueue, WGPUQueueWorkDoneStatus_Error);
+ EXPECT_CALL(api, OnQueueOnSubmittedWorkDone2(apiQueue, _)).WillOnce(InvokeWithoutArgs([&] {
+ api.CallQueueOnSubmittedWorkDone2Callback(apiQueue, WGPUQueueWorkDoneStatus_Error);
}));
FlushClient();
@@ -141,8 +141,8 @@
static constexpr size_t kNumRequests = 10;
OnSubmittedWorkDone();
- EXPECT_CALL(api, OnQueueOnSubmittedWorkDone(apiQueue, _)).WillOnce(InvokeWithoutArgs([&] {
- api.CallQueueOnSubmittedWorkDoneCallback(apiQueue, WGPUQueueWorkDoneStatus_Error);
+ EXPECT_CALL(api, OnQueueOnSubmittedWorkDone2(apiQueue, _)).WillOnce(InvokeWithoutArgs([&] {
+ api.CallQueueOnSubmittedWorkDone2Callback(apiQueue, WGPUQueueWorkDoneStatus_Error);
}));
FlushClient();
diff --git a/src/dawn/tests/unittests/wire/WireShaderModuleTests.cpp b/src/dawn/tests/unittests/wire/WireShaderModuleTests.cpp
index 9455b0d..dd89a96 100644
--- a/src/dawn/tests/unittests/wire/WireShaderModuleTests.cpp
+++ b/src/dawn/tests/unittests/wire/WireShaderModuleTests.cpp
@@ -40,7 +40,7 @@
using testing::Mock;
using testing::Return;
-using WireShaderModuleTestBase = WireFutureTest<wgpu::CompilationInfoCallback<void>*>;
+using WireShaderModuleTestBase = WireFutureTest<wgpu::CompilationInfoCallback2<void>*>;
class WireShaderModuleTests : public WireShaderModuleTestBase {
protected:
void GetCompilationInfo() {
@@ -90,9 +90,9 @@
TEST_P(WireShaderModuleTests, GetCompilationInfo) {
GetCompilationInfo();
- EXPECT_CALL(api, OnShaderModuleGetCompilationInfo(apiShaderModule, _))
+ EXPECT_CALL(api, OnShaderModuleGetCompilationInfo2(apiShaderModule, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallShaderModuleGetCompilationInfoCallback(
+ api.CallShaderModuleGetCompilationInfo2Callback(
apiShaderModule, WGPUCompilationInfoRequestStatus_Success,
reinterpret_cast<const WGPUCompilationInfo*>(&mCompilationInfo));
}));
@@ -127,9 +127,9 @@
TEST_P(WireShaderModuleTests, GetCompilationInfoBeforeDisconnect) {
GetCompilationInfo();
- EXPECT_CALL(api, OnShaderModuleGetCompilationInfo(apiShaderModule, _))
+ EXPECT_CALL(api, OnShaderModuleGetCompilationInfo2(apiShaderModule, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallShaderModuleGetCompilationInfoCallback(
+ api.CallShaderModuleGetCompilationInfo2Callback(
apiShaderModule, WGPUCompilationInfoRequestStatus_Success,
reinterpret_cast<const WGPUCompilationInfo*>(&mCompilationInfo));
}));
@@ -163,9 +163,9 @@
GetCompilationInfo();
- EXPECT_CALL(api, OnShaderModuleGetCompilationInfo(apiShaderModule, _))
+ EXPECT_CALL(api, OnShaderModuleGetCompilationInfo2(apiShaderModule, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallShaderModuleGetCompilationInfoCallback(
+ api.CallShaderModuleGetCompilationInfo2Callback(
apiShaderModule, WGPUCompilationInfoRequestStatus_Success,
reinterpret_cast<const WGPUCompilationInfo*>(&mCompilationInfo));
}));
@@ -192,9 +192,9 @@
GetCompilationInfo();
- EXPECT_CALL(api, OnShaderModuleGetCompilationInfo(apiShaderModule, _))
+ EXPECT_CALL(api, OnShaderModuleGetCompilationInfo2(apiShaderModule, _))
.WillOnce(InvokeWithoutArgs([&] {
- api.CallShaderModuleGetCompilationInfoCallback(
+ api.CallShaderModuleGetCompilationInfo2Callback(
apiShaderModule, WGPUCompilationInfoRequestStatus_Success,
reinterpret_cast<const WGPUCompilationInfo*>(&mCompilationInfo));
}));
diff --git a/src/dawn/wire/client/Buffer.cpp b/src/dawn/wire/client/Buffer.cpp
index a4afb34..784b039 100644
--- a/src/dawn/wire/client/Buffer.cpp
+++ b/src/dawn/wire/client/Buffer.cpp
@@ -62,6 +62,157 @@
MapAsyncEvent(const WGPUBufferMapCallbackInfo& callbackInfo, Ref<Buffer> buffer)
: TrackedEvent(callbackInfo.mode),
mCallback(callbackInfo.callback),
+ mUserdata(callbackInfo.userdata),
+ mBuffer(std::move(buffer)) {
+ DAWN_ASSERT(mBuffer != nullptr);
+ }
+
+ EventType GetType() override { return kType; }
+
+ bool IsPendingRequest(FutureID futureID) {
+ return mBuffer->mPendingMapRequest && mBuffer->mPendingMapRequest->futureID == futureID;
+ }
+
+ WireResult ReadyHook(FutureID futureID,
+ WGPUBufferMapAsyncStatus status,
+ uint64_t readDataUpdateInfoLength = 0,
+ const uint8_t* readDataUpdateInfo = nullptr) {
+ auto FailRequest = [this]() -> WireResult {
+ mStatus = WGPUBufferMapAsyncStatus_Unknown;
+ return WireResult::FatalError;
+ };
+
+ // Handling for different statuses.
+ switch (status) {
+ case WGPUBufferMapAsyncStatus_MappingAlreadyPending: {
+ DAWN_ASSERT(!IsPendingRequest(futureID));
+ mStatus = status;
+ break;
+ }
+
+ // For client-side rejection errors, we clear the pending request now since they always
+ // take precedence.
+ case WGPUBufferMapAsyncStatus_DestroyedBeforeCallback:
+ case WGPUBufferMapAsyncStatus_UnmappedBeforeCallback: {
+ mStatus = status;
+ mBuffer->mPendingMapRequest = std::nullopt;
+ break;
+ }
+
+ case WGPUBufferMapAsyncStatus_Success: {
+ if (!IsPendingRequest(futureID)) {
+ // If a success occurs (which must come from the server), but it does not
+ // correspond to the pending request, the pending request must have been
+ // rejected early and hence the status must be set.
+ DAWN_ASSERT(mStatus);
+ break;
+ }
+ mStatus = status;
+ auto& pending = mBuffer->mPendingMapRequest.value();
+ if (!pending.type) {
+ return FailRequest();
+ }
+ switch (*pending.type) {
+ case MapRequestType::Read: {
+ if (readDataUpdateInfoLength > std::numeric_limits<size_t>::max()) {
+ // This is the size of data deserialized from the command stream, which
+ // must be CPU-addressable.
+ return FailRequest();
+ }
+
+ // Validate to prevent bad map request; buffer destroyed during map request
+ if (mBuffer->mReadHandle == nullptr) {
+ return FailRequest();
+ }
+ // Update user map data with server returned data
+ if (!mBuffer->mReadHandle->DeserializeDataUpdate(
+ readDataUpdateInfo, static_cast<size_t>(readDataUpdateInfoLength),
+ pending.offset, pending.size)) {
+ return FailRequest();
+ }
+ mBuffer->mMappedData = const_cast<void*>(mBuffer->mReadHandle->GetData());
+ break;
+ }
+ case MapRequestType::Write: {
+ if (mBuffer->mWriteHandle == nullptr) {
+ return FailRequest();
+ }
+ mBuffer->mMappedData = mBuffer->mWriteHandle->GetData();
+ break;
+ }
+ }
+ mBuffer->mMappedOffset = pending.offset;
+ mBuffer->mMappedSize = pending.size;
+ break;
+ }
+
+ // All other statuses are server-side status.
+ default: {
+ if (!IsPendingRequest(futureID)) {
+ break;
+ }
+ mStatus = status;
+ }
+ }
+ return WireResult::Success;
+ }
+
+ private:
+ void CompleteImpl(FutureID futureID, EventCompletionType completionType) override {
+ WGPUBufferMapAsyncStatus status = completionType == EventCompletionType::Shutdown
+ ? WGPUBufferMapAsyncStatus_DeviceLost
+ : WGPUBufferMapAsyncStatus_Success;
+ if (mStatus) {
+ status = *mStatus;
+ }
+
+ auto Callback = [this, &status]() {
+ if (mCallback) {
+ mCallback(status, mUserdata.ExtractAsDangling());
+ }
+ };
+
+ if (!IsPendingRequest(futureID)) {
+ DAWN_ASSERT(status != WGPUBufferMapAsyncStatus_Success);
+ return Callback();
+ }
+
+ // Device destruction/loss implicitly makes the map requests aborted.
+ if (!mBuffer->mDevice->IsAlive()) {
+ status = WGPUBufferMapAsyncStatus_DestroyedBeforeCallback;
+ }
+
+ if (status == WGPUBufferMapAsyncStatus_Success) {
+ DAWN_ASSERT(mBuffer->mPendingMapRequest->type);
+ switch (*mBuffer->mPendingMapRequest->type) {
+ case MapRequestType::Read:
+ mBuffer->mMappedState = MapState::MappedForRead;
+ break;
+ case MapRequestType::Write:
+ mBuffer->mMappedState = MapState::MappedForWrite;
+ break;
+ }
+ }
+ mBuffer->mPendingMapRequest = std::nullopt;
+ return Callback();
+ }
+
+ WGPUBufferMapCallback mCallback;
+ raw_ptr<void> mUserdata;
+
+ std::optional<WGPUBufferMapAsyncStatus> mStatus;
+
+ // Reference to the buffer to handle the internal states.
+ Ref<Buffer> mBuffer;
+};
+
+class Buffer::MapAsyncEvent2 : public TrackedEvent {
+ public:
+ static constexpr EventType kType = EventType::MapAsync;
+
+ MapAsyncEvent2(const WGPUBufferMapCallbackInfo2& callbackInfo, Ref<Buffer> buffer)
+ : TrackedEvent(callbackInfo.mode),
+ mCallback(callbackInfo.callback),
mUserdata1(callbackInfo.userdata1),
mUserdata2(callbackInfo.userdata2),
mBuffer(buffer) {
@@ -171,7 +322,7 @@
return Callback();
}
- WGPUBufferMapCallback mCallback;
+ WGPUBufferMapCallback2 mCallback;
raw_ptr<void> mUserdata1;
raw_ptr<void> mUserdata2;
@@ -307,30 +458,61 @@
}
void Buffer::WillDropLastExternalRef() {
- SetFutureStatus(WGPUMapAsyncStatus_Aborted,
- "Buffer was destroyed before mapping was resolved.");
+ SetFutureStatus(WGPUBufferMapAsyncStatus_DestroyedBeforeCallback);
}
ObjectType Buffer::GetObjectType() const {
return ObjectType::Buffer;
}
-void Buffer::SetFutureStatus(WGPUMapAsyncStatus status, std::string_view message) {
+void Buffer::SetFutureStatus(WGPUBufferMapAsyncStatus status) {
if (!mPendingMapRequest) {
return;
}
FutureID futureID = mPendingMapRequest->futureID;
+ bool isNewEntryPoint = mPendingMapRequest->isNewEntryPoint;
mPendingMapRequest = std::nullopt;
- DAWN_CHECK(GetEventManager().SetFutureReady<MapAsyncEvent>(
- futureID, status, ToOutputStringView(message)) == WireResult::Success);
+ if (isNewEntryPoint) {
+ auto [newStatus, message] =
+ [](WGPUBufferMapAsyncStatus status) -> std::pair<WGPUMapAsyncStatus, std::string_view> {
+ switch (status) {
+ case WGPUBufferMapAsyncStatus_DestroyedBeforeCallback:
+ return {WGPUMapAsyncStatus_Aborted,
+ "Buffer was destroyed before mapping was resolved."};
+ case WGPUBufferMapAsyncStatus_UnmappedBeforeCallback:
+ return {WGPUMapAsyncStatus_Aborted,
+ "Buffer was unmapped before mapping was resolved."};
+ default:
+ DAWN_UNREACHABLE();
+ }
+ }(status);
+
+ DAWN_CHECK(GetEventManager().SetFutureReady<MapAsyncEvent2>(
+ futureID, newStatus, ToOutputStringView(message)) == WireResult::Success);
+ } else {
+ DAWN_CHECK(GetEventManager().SetFutureReady<MapAsyncEvent>(futureID, status) ==
+ WireResult::Success);
+ }
}
-WGPUFuture Buffer::MapAsync(WGPUMapMode mode,
- size_t offset,
- size_t size,
- const WGPUBufferMapCallbackInfo& callbackInfo) {
+void Buffer::MapAsync(WGPUMapMode mode,
+ size_t offset,
+ size_t size,
+ WGPUBufferMapCallback callback,
+ void* userdata) {
+ WGPUBufferMapCallbackInfo callbackInfo = {};
+ callbackInfo.mode = WGPUCallbackMode_AllowSpontaneous;
+ callbackInfo.callback = callback;
+ callbackInfo.userdata = userdata;
+ MapAsyncF(mode, offset, size, callbackInfo);
+}
+
+WGPUFuture Buffer::MapAsyncF(WGPUMapMode mode,
+ size_t offset,
+ size_t size,
+ const WGPUBufferMapCallbackInfo& callbackInfo) {
Client* client = GetClient();
auto [futureIDInternal, tracked] =
GetEventManager().TrackEvent(std::make_unique<MapAsyncEvent>(callbackInfo, this));
@@ -340,6 +522,52 @@
if (mPendingMapRequest) {
[[maybe_unused]] auto id = GetEventManager().SetFutureReady<MapAsyncEvent>(
+ futureIDInternal, WGPUBufferMapAsyncStatus_MappingAlreadyPending);
+ return {futureIDInternal};
+ }
+
+ // Handle the defaulting of size required by WebGPU.
+ if ((size == WGPU_WHOLE_MAP_SIZE) && (offset <= mSize)) {
+ size = mSize - offset;
+ }
+
+ // Set up the request structure that will hold information while this mapping is in flight.
+ std::optional<MapRequestType> mapMode;
+ if (mode & WGPUMapMode_Read) {
+ mapMode = MapRequestType::Read;
+ } else if (mode & WGPUMapMode_Write) {
+ mapMode = MapRequestType::Write;
+ }
+
+ mPendingMapRequest = {futureIDInternal, offset, size, mapMode, false};
+
+ // Serialize the command to send to the server.
+ BufferMapAsyncCmd cmd;
+ cmd.bufferId = GetWireId();
+ cmd.eventManagerHandle = GetEventManagerHandle();
+ cmd.future = {futureIDInternal};
+ cmd.mode = mode;
+ cmd.offset = offset;
+ cmd.size = size;
+ cmd.userdataCount = 1;
+
+ client->SerializeCommand(cmd);
+ return {futureIDInternal};
+}
+
+WGPUFuture Buffer::MapAsync2(WGPUMapMode mode,
+ size_t offset,
+ size_t size,
+ const WGPUBufferMapCallbackInfo2& callbackInfo) {
+ Client* client = GetClient();
+ auto [futureIDInternal, tracked] =
+ GetEventManager().TrackEvent(std::make_unique<MapAsyncEvent2>(callbackInfo, this));
+ if (!tracked) {
+ return {futureIDInternal};
+ }
+
+ if (mPendingMapRequest) {
+ [[maybe_unused]] auto id = GetEventManager().SetFutureReady<MapAsyncEvent2>(
futureIDInternal, WGPUMapAsyncStatus_Error,
ToOutputStringView("Buffer already has an outstanding map pending."));
return {futureIDInternal};
@@ -358,7 +586,7 @@
mapMode = MapRequestType::Write;
}
- mPendingMapRequest = {futureIDInternal, offset, size, mapMode};
+ mPendingMapRequest = {futureIDInternal, offset, size, mapMode, true};
// Serialize the command to send to the server.
BufferMapAsyncCmd cmd;
@@ -368,6 +596,7 @@
cmd.mode = mode;
cmd.offset = offset;
cmd.size = size;
+ cmd.userdataCount = 2;
client->SerializeCommand(cmd);
return {futureIDInternal};
@@ -375,13 +604,21 @@
WireResult Client::DoBufferMapAsyncCallback(ObjectHandle eventManager,
WGPUFuture future,
- WGPUMapAsyncStatus status,
+ WGPUBufferMapAsyncStatus status,
+ WGPUMapAsyncStatus status2,
WGPUStringView message,
+ uint8_t userdataCount,
uint64_t readDataUpdateInfoLength,
const uint8_t* readDataUpdateInfo) {
- return GetEventManager(eventManager)
- .SetFutureReady<Buffer::MapAsyncEvent>(future.id, status, message, readDataUpdateInfoLength,
- readDataUpdateInfo);
+ if (userdataCount == 1) {
+ return GetEventManager(eventManager)
+ .SetFutureReady<Buffer::MapAsyncEvent>(future.id, status, readDataUpdateInfoLength,
+ readDataUpdateInfo);
+ } else {
+ return GetEventManager(eventManager)
+ .SetFutureReady<Buffer::MapAsyncEvent2>(future.id, status2, message,
+ readDataUpdateInfoLength, readDataUpdateInfo);
+ }
}
void* Buffer::GetMappedRange(size_t offset, size_t size) {
@@ -457,7 +694,7 @@
cmd.self = ToAPI(this);
client->SerializeCommand(cmd);
- SetFutureStatus(WGPUMapAsyncStatus_Aborted, "Buffer was unmapped before mapping was resolved.");
+ SetFutureStatus(WGPUBufferMapAsyncStatus_UnmappedBeforeCallback);
}
void Buffer::Destroy() {
@@ -470,8 +707,7 @@
cmd.self = ToAPI(this);
client->SerializeCommand(cmd);
- SetFutureStatus(WGPUMapAsyncStatus_Aborted,
- "Buffer was destroyed before mapping was resolved.");
+ SetFutureStatus(WGPUBufferMapAsyncStatus_DestroyedBeforeCallback);
}
WGPUBufferUsage Buffer::GetUsage() const {
diff --git a/src/dawn/wire/client/Buffer.h b/src/dawn/wire/client/Buffer.h
index f8e48f4..533635d 100644
--- a/src/dawn/wire/client/Buffer.h
+++ b/src/dawn/wire/client/Buffer.h
@@ -57,10 +57,19 @@
ObjectType GetObjectType() const override;
- WGPUFuture MapAsync(WGPUMapMode mode,
- size_t offset,
- size_t size,
- const WGPUBufferMapCallbackInfo& callbackInfo);
+ void MapAsync(WGPUMapMode mode,
+ size_t offset,
+ size_t size,
+ WGPUBufferMapCallback callback,
+ void* userdata);
+ WGPUFuture MapAsyncF(WGPUMapMode mode,
+ size_t offset,
+ size_t size,
+ const WGPUBufferMapCallbackInfo& callbackInfo);
+ WGPUFuture MapAsync2(WGPUMapMode mode,
+ size_t offset,
+ size_t size,
+ const WGPUBufferMapCallbackInfo2& callbackInfo);
void* GetMappedRange(size_t offset, size_t size);
const void* GetConstMappedRange(size_t offset, size_t size);
void Unmap();
@@ -76,11 +85,12 @@
private:
friend class Client;
class MapAsyncEvent;
+ class MapAsyncEvent2;
void WillDropLastExternalRef() override;
// Prepares the callbacks to be called and potentially calls them
- void SetFutureStatus(WGPUMapAsyncStatus status, std::string_view message);
+ void SetFutureStatus(WGPUBufferMapAsyncStatus status);
bool IsMappedForReading() const;
bool IsMappedForWriting() const;
@@ -102,6 +112,9 @@
// Because validation for request type is validated via the backend, we use an optional type
// here. This is nullopt when an invalid request type is passed to the wire.
std::optional<MapRequestType> type;
+ // Currently needs an additional boolean to indicate which entry point was used for the map.
+ // TODO(crbug.com/42241461): Remove this once we don't need to support both on the wire.
+ bool isNewEntryPoint = false;
};
enum class MapState {
Unmapped,
diff --git a/src/dawn/wire/client/Device.cpp b/src/dawn/wire/client/Device.cpp
index 1b4960e..4677663 100644
--- a/src/dawn/wire/client/Device.cpp
+++ b/src/dawn/wire/client/Device.cpp
@@ -46,7 +46,7 @@
public:
static constexpr EventType kType = EventType::PopErrorScope;
- explicit PopErrorScopeEvent(const WGPUPopErrorScopeCallbackInfo& callbackInfo)
+ explicit PopErrorScopeEvent(const WGPUPopErrorScopeCallbackInfo2& callbackInfo)
: TrackedEvent(callbackInfo.mode),
mCallback(callbackInfo.callback),
mUserdata1(callbackInfo.userdata1),
@@ -72,7 +72,7 @@
}
}
- WGPUPopErrorScopeCallback mCallback;
+ WGPUPopErrorScopeCallback2 mCallback;
raw_ptr<void> mUserdata1;
raw_ptr<void> mUserdata2;
@@ -145,11 +145,11 @@
using CreateComputePipelineEvent =
CreatePipelineEventBase<ComputePipeline,
EventType::CreateComputePipeline,
- WGPUCreateComputePipelineAsyncCallbackInfo>;
+ WGPUCreateComputePipelineAsyncCallbackInfo2>;
using CreateRenderPipelineEvent =
CreatePipelineEventBase<RenderPipeline,
EventType::CreateRenderPipeline,
- WGPUCreateRenderPipelineAsyncCallbackInfo>;
+ WGPUCreateRenderPipelineAsyncCallbackInfo2>;
static constexpr WGPUUncapturedErrorCallbackInfo2 kEmptyUncapturedErrorCallbackInfo = {
nullptr, nullptr, nullptr, nullptr};
@@ -348,7 +348,30 @@
.SetFutureReady<Device::DeviceLostEvent>(future.id, reason, message);
}
-WGPUFuture Device::PopErrorScope(const WGPUPopErrorScopeCallbackInfo& callbackInfo) {
+void Device::PopErrorScope(WGPUErrorCallback callback, void* userdata) {
+ static WGPUErrorCallback kDefaultCallback = [](WGPUErrorType, WGPUStringView, void*) {};
+
+ PopErrorScope2({nullptr, WGPUCallbackMode_AllowSpontaneous,
+ [](WGPUPopErrorScopeStatus, WGPUErrorType type, WGPUStringView message,
+ void* callback, void* userdata) {
+ auto cb = reinterpret_cast<WGPUErrorCallback>(callback);
+ cb(type, message, userdata);
+ },
+ reinterpret_cast<void*>(callback != nullptr ? callback : kDefaultCallback),
+ userdata});
+}
+
+WGPUFuture Device::PopErrorScopeF(const WGPUPopErrorScopeCallbackInfo& callbackInfo) {
+ return PopErrorScope2({callbackInfo.nextInChain, callbackInfo.mode,
+ [](WGPUPopErrorScopeStatus status, WGPUErrorType type,
+ WGPUStringView message, void* callback, void* userdata) {
+ auto cb = reinterpret_cast<WGPUPopErrorScopeCallback>(callback);
+ cb(status, type, message, userdata);
+ },
+ reinterpret_cast<void*>(callbackInfo.callback), callbackInfo.userdata});
+}
+
+WGPUFuture Device::PopErrorScope2(const WGPUPopErrorScopeCallbackInfo2& callbackInfo) {
Client* client = GetClient();
auto [futureIDInternal, tracked] =
GetEventManager().TrackEvent(std::make_unique<PopErrorScopeEvent>(callbackInfo));
@@ -415,8 +438,8 @@
}
template <typename Event, typename Cmd, typename CallbackInfo, typename Descriptor>
-WGPUFuture Device::CreatePipelineAsync(Descriptor const* descriptor,
- const CallbackInfo& callbackInfo) {
+WGPUFuture Device::CreatePipelineAsyncF(Descriptor const* descriptor,
+ const CallbackInfo& callbackInfo) {
using Pipeline = typename Event::Pipeline;
Client* client = GetClient();
@@ -438,10 +461,38 @@
return {futureIDInternal};
}
-WGPUFuture Device::CreateComputePipelineAsync(
+void Device::CreateComputePipelineAsync(WGPUComputePipelineDescriptor const* descriptor,
+ WGPUCreateComputePipelineAsyncCallback callback,
+ void* userdata) {
+ CreateComputePipelineAsync2(
+ descriptor, {nullptr, WGPUCallbackMode_AllowSpontaneous,
+ [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline,
+ WGPUStringView message, void* callback, void* userdata) {
+ auto cb =
+ reinterpret_cast<WGPUCreateComputePipelineAsyncCallback>(callback);
+ cb(status, pipeline, message, userdata);
+ },
+ reinterpret_cast<void*>(callback), userdata});
+}
+
+WGPUFuture Device::CreateComputePipelineAsyncF(
WGPUComputePipelineDescriptor const* descriptor,
const WGPUCreateComputePipelineAsyncCallbackInfo& callbackInfo) {
- return CreatePipelineAsync<CreateComputePipelineEvent, DeviceCreateComputePipelineAsyncCmd>(
+ return CreateComputePipelineAsync2(
+ descriptor, {callbackInfo.nextInChain, callbackInfo.mode,
+ [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline,
+ WGPUStringView message, void* callback, void* userdata) {
+ auto cb =
+ reinterpret_cast<WGPUCreateComputePipelineAsyncCallback>(callback);
+ cb(status, pipeline, message, userdata);
+ },
+ reinterpret_cast<void*>(callbackInfo.callback), callbackInfo.userdata});
+}
+
+WGPUFuture Device::CreateComputePipelineAsync2(
+ WGPUComputePipelineDescriptor const* descriptor,
+ const WGPUCreateComputePipelineAsyncCallbackInfo2& callbackInfo) {
+ return CreatePipelineAsyncF<CreateComputePipelineEvent, DeviceCreateComputePipelineAsyncCmd>(
descriptor, callbackInfo);
}
@@ -453,10 +504,38 @@
.SetFutureReady<CreateComputePipelineEvent>(future.id, status, message);
}
-WGPUFuture Device::CreateRenderPipelineAsync(
+void Device::CreateRenderPipelineAsync(WGPURenderPipelineDescriptor const* descriptor,
+ WGPUCreateRenderPipelineAsyncCallback callback,
+ void* userdata) {
+ CreateRenderPipelineAsync2(
+ descriptor, {nullptr, WGPUCallbackMode_AllowSpontaneous,
+ [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline,
+ WGPUStringView message, void* callback, void* userdata) {
+ auto cb =
+ reinterpret_cast<WGPUCreateRenderPipelineAsyncCallback>(callback);
+ cb(status, pipeline, message, userdata);
+ },
+ reinterpret_cast<void*>(callback), userdata});
+}
+
+WGPUFuture Device::CreateRenderPipelineAsyncF(
WGPURenderPipelineDescriptor const* descriptor,
const WGPUCreateRenderPipelineAsyncCallbackInfo& callbackInfo) {
- return CreatePipelineAsync<CreateRenderPipelineEvent, DeviceCreateRenderPipelineAsyncCmd>(
+ return CreateRenderPipelineAsync2(
+ descriptor, {callbackInfo.nextInChain, callbackInfo.mode,
+ [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline,
+ WGPUStringView message, void* callback, void* userdata) {
+ auto cb =
+ reinterpret_cast<WGPUCreateRenderPipelineAsyncCallback>(callback);
+ cb(status, pipeline, message, userdata);
+ },
+ reinterpret_cast<void*>(callbackInfo.callback), callbackInfo.userdata});
+}
+
+WGPUFuture Device::CreateRenderPipelineAsync2(
+ WGPURenderPipelineDescriptor const* descriptor,
+ const WGPUCreateRenderPipelineAsyncCallbackInfo2& callbackInfo) {
+ return CreatePipelineAsyncF<CreateRenderPipelineEvent, DeviceCreateRenderPipelineAsyncCmd>(
descriptor, callbackInfo);
}
diff --git a/src/dawn/wire/client/Device.h b/src/dawn/wire/client/Device.h
index 5efef24..5f7a1a4 100644
--- a/src/dawn/wire/client/Device.h
+++ b/src/dawn/wire/client/Device.h
@@ -67,16 +67,30 @@
// WebGPU API
void SetLoggingCallback(WGPULoggingCallback errorCallback, void* errorUserdata);
void InjectError(WGPUErrorType type, WGPUStringView message);
- WGPUFuture PopErrorScope(const WGPUPopErrorScopeCallbackInfo& callbackInfo);
+ void PopErrorScope(WGPUErrorCallback callback, void* userdata);
+ WGPUFuture PopErrorScopeF(const WGPUPopErrorScopeCallbackInfo& callbackInfo);
+ WGPUFuture PopErrorScope2(const WGPUPopErrorScopeCallbackInfo2& callbackInfo);
WGPUBuffer CreateBuffer(const WGPUBufferDescriptor* descriptor);
WGPUBuffer CreateErrorBuffer(const WGPUBufferDescriptor* descriptor);
- WGPUFuture CreateComputePipelineAsync(
+ void CreateComputePipelineAsync(WGPUComputePipelineDescriptor const* descriptor,
+ WGPUCreateComputePipelineAsyncCallback callback,
+ void* userdata);
+ WGPUFuture CreateComputePipelineAsyncF(
WGPUComputePipelineDescriptor const* descriptor,
const WGPUCreateComputePipelineAsyncCallbackInfo& callbackInfo);
- WGPUFuture CreateRenderPipelineAsync(
+ WGPUFuture CreateComputePipelineAsync2(
+ WGPUComputePipelineDescriptor const* descriptor,
+ const WGPUCreateComputePipelineAsyncCallbackInfo2& callbackInfo);
+ void CreateRenderPipelineAsync(WGPURenderPipelineDescriptor const* descriptor,
+ WGPUCreateRenderPipelineAsyncCallback callback,
+ void* userdata);
+ WGPUFuture CreateRenderPipelineAsyncF(
WGPURenderPipelineDescriptor const* descriptor,
const WGPUCreateRenderPipelineAsyncCallbackInfo& callbackInfo);
+ WGPUFuture CreateRenderPipelineAsync2(
+ WGPURenderPipelineDescriptor const* descriptor,
+ const WGPUCreateRenderPipelineAsyncCallbackInfo2& callbackInfo);
WGPUStatus GetLimits(WGPUSupportedLimits* limits) const;
WGPUFuture GetLostFuture();
@@ -94,7 +108,7 @@
typename Cmd,
typename CallbackInfo = typename Event::CallbackInfo,
typename Descriptor = decltype(std::declval<Cmd>().descriptor)>
- WGPUFuture CreatePipelineAsync(Descriptor const* descriptor, const CallbackInfo& callbackInfo);
+ WGPUFuture CreatePipelineAsyncF(Descriptor const* descriptor, const CallbackInfo& callbackInfo);
LimitsAndFeatures mLimitsAndFeatures;
diff --git a/src/dawn/wire/client/Queue.cpp b/src/dawn/wire/client/Queue.cpp
index e5093dc..2680e16 100644
--- a/src/dawn/wire/client/Queue.cpp
+++ b/src/dawn/wire/client/Queue.cpp
@@ -41,7 +41,7 @@
public:
static constexpr EventType kType = EventType::WorkDone;
- explicit WorkDoneEvent(const WGPUQueueWorkDoneCallbackInfo& callbackInfo)
+ explicit WorkDoneEvent(const WGPUQueueWorkDoneCallbackInfo2& callbackInfo)
: TrackedEvent(callbackInfo.mode),
mCallback(callbackInfo.callback),
mUserdata1(callbackInfo.userdata1),
@@ -59,6 +59,9 @@
if (completionType == EventCompletionType::Shutdown) {
mStatus = WGPUQueueWorkDoneStatus_InstanceDropped;
}
+ if (mStatus == WGPUQueueWorkDoneStatus_DeviceLost) {
+ mStatus = WGPUQueueWorkDoneStatus_Success;
+ }
void* userdata1 = mUserdata1.ExtractAsDangling();
void* userdata2 = mUserdata2.ExtractAsDangling();
if (mCallback) {
@@ -66,7 +69,7 @@
}
}
- WGPUQueueWorkDoneCallback mCallback;
+ WGPUQueueWorkDoneCallback2 mCallback;
raw_ptr<void> mUserdata1;
raw_ptr<void> mUserdata2;
@@ -87,7 +90,41 @@
return GetEventManager(eventManager).SetFutureReady<WorkDoneEvent>(future.id, status);
}
-WGPUFuture Queue::OnSubmittedWorkDone(const WGPUQueueWorkDoneCallbackInfo& callbackInfo) {
+void Queue::OnSubmittedWorkDone(WGPUQueueWorkDoneCallback callback, void* userdata) {
+ OnSubmittedWorkDoneF({nullptr, WGPUCallbackMode_AllowSpontaneous, callback, userdata});
+}
+
+WGPUFuture Queue::OnSubmittedWorkDoneF(const WGPUQueueWorkDoneCallbackInfo& callbackInfo) {
+ // TODO(crbug.com/dawn/2052): Once we always return a future, change this to log to the instance
+ // (note, not raise a validation error to the device) and return the null future.
+ DAWN_ASSERT(callbackInfo.nextInChain == nullptr);
+
+ Client* client = GetClient();
+ auto [futureIDInternal, tracked] =
+ GetEventManager().TrackEvent(std::make_unique<WorkDoneEvent>(WGPUQueueWorkDoneCallbackInfo2{
+ callbackInfo.nextInChain, callbackInfo.mode,
+ [](WGPUQueueWorkDoneStatus status, void* callback, void* userdata) {
+ auto cb = reinterpret_cast<WGPUQueueWorkDoneCallback>(callback);
+ cb(status, userdata);
+ },
+ reinterpret_cast<void*>(callbackInfo.callback != nullptr ? callbackInfo.callback
+ : nullptr),
+ callbackInfo.userdata}));
+ if (!tracked) {
+ return {futureIDInternal};
+ }
+
+ QueueOnSubmittedWorkDoneCmd cmd;
+ cmd.queueId = GetWireId();
+ cmd.eventManagerHandle = GetEventManagerHandle();
+ cmd.future = {futureIDInternal};
+ cmd.userdataCount = 1;
+
+ client->SerializeCommand(cmd);
+ return {futureIDInternal};
+}
+
+WGPUFuture Queue::OnSubmittedWorkDone2(const WGPUQueueWorkDoneCallbackInfo2& callbackInfo) {
// TODO(crbug.com/dawn/2052): Once we always return a future, change this to log to the instance
// (note, not raise a validation error to the device) and return the null future.
DAWN_ASSERT(callbackInfo.nextInChain == nullptr);
@@ -103,6 +140,7 @@
cmd.queueId = GetWireId();
cmd.eventManagerHandle = GetEventManagerHandle();
cmd.future = {futureIDInternal};
+ cmd.userdataCount = 2;
client->SerializeCommand(cmd);
return {futureIDInternal};
diff --git a/src/dawn/wire/client/Queue.h b/src/dawn/wire/client/Queue.h
index 0f95a42..bec29d7 100644
--- a/src/dawn/wire/client/Queue.h
+++ b/src/dawn/wire/client/Queue.h
@@ -43,7 +43,9 @@
ObjectType GetObjectType() const override;
// Dawn API
- WGPUFuture OnSubmittedWorkDone(const WGPUQueueWorkDoneCallbackInfo& callbackInfo);
+ void OnSubmittedWorkDone(WGPUQueueWorkDoneCallback callback, void* userdata);
+ WGPUFuture OnSubmittedWorkDoneF(const WGPUQueueWorkDoneCallbackInfo& callbackInfo);
+ WGPUFuture OnSubmittedWorkDone2(const WGPUQueueWorkDoneCallbackInfo2& callbackInfo);
void WriteBuffer(WGPUBuffer cBuffer, uint64_t bufferOffset, const void* data, size_t size);
void WriteTexture(const WGPUImageCopyTexture* destination,
const void* data,
diff --git a/src/dawn/wire/client/ShaderModule.cpp b/src/dawn/wire/client/ShaderModule.cpp
index 79fea77..614489b 100644
--- a/src/dawn/wire/client/ShaderModule.cpp
+++ b/src/dawn/wire/client/ShaderModule.cpp
@@ -40,7 +40,7 @@
public:
static constexpr EventType kType = EventType::CompilationInfo;
- CompilationInfoEvent(const WGPUCompilationInfoCallbackInfo& callbackInfo,
+ CompilationInfoEvent(const WGPUCompilationInfoCallbackInfo2& callbackInfo,
Ref<ShaderModule> shader)
: TrackedEvent(callbackInfo.mode),
mCallback(callbackInfo.callback),
@@ -102,7 +102,7 @@
}
}
- WGPUCompilationInfoCallback mCallback;
+ WGPUCompilationInfoCallback2 mCallback;
raw_ptr<void> mUserdata1;
raw_ptr<void> mUserdata2;
@@ -117,7 +117,39 @@
return ObjectType::ShaderModule;
}
-WGPUFuture ShaderModule::GetCompilationInfo(const WGPUCompilationInfoCallbackInfo& callbackInfo) {
+namespace {
+
+void DefaultGetCompilationInfoCallback(WGPUCompilationInfoRequestStatus status,
+ const WGPUCompilationInfo* compilationInfo,
+ void* callback,
+ void* userdata) {
+ if (callback == nullptr) {
+ DAWN_ASSERT(userdata == nullptr);
+ return;
+ }
+ auto cb = reinterpret_cast<WGPUCompilationInfoCallback>(callback);
+ cb(status, compilationInfo, userdata);
+}
+
+} // anonymous namespace
+
+void ShaderModule::GetCompilationInfo(WGPUCompilationInfoCallback callback, void* userdata) {
+ if (callback == nullptr) {
+ DAWN_ASSERT(userdata == nullptr);
+ return;
+ }
+ GetCompilationInfo2({nullptr, WGPUCallbackMode_AllowSpontaneous,
+ &DefaultGetCompilationInfoCallback, reinterpret_cast<void*>(callback),
+ userdata});
+}
+
+WGPUFuture ShaderModule::GetCompilationInfoF(const WGPUCompilationInfoCallbackInfo& callbackInfo) {
+ return GetCompilationInfo2(
+ {callbackInfo.nextInChain, callbackInfo.mode, &DefaultGetCompilationInfoCallback,
+ reinterpret_cast<void*>(callbackInfo.callback), callbackInfo.userdata});
+}
+
+WGPUFuture ShaderModule::GetCompilationInfo2(const WGPUCompilationInfoCallbackInfo2& callbackInfo) {
auto [futureIDInternal, tracked] =
GetEventManager().TrackEvent(std::make_unique<CompilationInfoEvent>(callbackInfo, this));
if (!tracked) {
diff --git a/src/dawn/wire/client/ShaderModule.h b/src/dawn/wire/client/ShaderModule.h
index a278196..d0558f6 100644
--- a/src/dawn/wire/client/ShaderModule.h
+++ b/src/dawn/wire/client/ShaderModule.h
@@ -44,7 +44,9 @@
ObjectType GetObjectType() const override;
- WGPUFuture GetCompilationInfo(const WGPUCompilationInfoCallbackInfo& callbackInfo);
+ void GetCompilationInfo(WGPUCompilationInfoCallback callback, void* userdata);
+ WGPUFuture GetCompilationInfoF(const WGPUCompilationInfoCallbackInfo& callbackInfo);
+ WGPUFuture GetCompilationInfo2(const WGPUCompilationInfoCallbackInfo2& callbackInfo);
private:
friend class Client;
diff --git a/src/dawn/wire/server/Server.h b/src/dawn/wire/server/Server.h
index 0241d31..4f0702f 100644
--- a/src/dawn/wire/server/Server.h
+++ b/src/dawn/wire/server/Server.h
@@ -129,6 +129,7 @@
uint64_t offset;
uint64_t size;
WGPUMapMode mode;
+ uint8_t userdataCount;
};
struct ErrorScopeUserdata : CallbackUserdata {
@@ -264,9 +265,10 @@
WGPUPopErrorScopeStatus status,
WGPUErrorType type,
WGPUStringView message);
- void OnBufferMapAsyncCallback(MapUserdata* userdata,
- WGPUMapAsyncStatus status,
- WGPUStringView message);
+ void OnBufferMapAsyncCallback(MapUserdata* userdata, WGPUBufferMapAsyncStatus status);
+ void OnBufferMapAsyncCallback2(MapUserdata* userdata,
+ WGPUMapAsyncStatus status,
+ WGPUStringView message);
void OnQueueWorkDone(QueueWorkDoneUserdata* userdata, WGPUQueueWorkDoneStatus status);
void OnCreateComputePipelineAsyncCallback(CreatePipelineAsyncUserData* userdata,
WGPUCreatePipelineAsyncStatus status,
diff --git a/src/dawn/wire/server/ServerBuffer.cpp b/src/dawn/wire/server/ServerBuffer.cpp
index 24fe5f5..e639966 100644
--- a/src/dawn/wire/server/ServerBuffer.cpp
+++ b/src/dawn/wire/server/ServerBuffer.cpp
@@ -71,7 +71,8 @@
WGPUFuture future,
WGPUMapMode mode,
uint64_t offset64,
- uint64_t size64) {
+ uint64_t size64,
+ uint8_t userdataCount) {
// These requests are just forwarded to the buffer, with userdata containing what the
// client will require in the return command.
std::unique_ptr<MapUserdata> userdata = MakeUserdata<MapUserdata>();
@@ -80,6 +81,7 @@
userdata->bufferObj = buffer->handle;
userdata->future = future;
userdata->mode = mode;
+ userdata->userdataCount = userdataCount;
// Make sure that the deserialized offset and size are no larger than
// std::numeric_limits<size_t>::max() so that they are CPU-addressable, and size is not
@@ -87,13 +89,11 @@
// client does the default size computation, we should always have a valid actual size here
// in server. All other invalid actual size can be caught by dawn native side validation.
if (offset64 > std::numeric_limits<size_t>::max()) {
- static constexpr WGPUStringView kOffsetOutOfRange = {"Buffer offset was out of range.", 31};
- OnBufferMapAsyncCallback(userdata.get(), WGPUMapAsyncStatus_Error, kOffsetOutOfRange);
+ OnBufferMapAsyncCallback(userdata.get(), WGPUBufferMapAsyncStatus_OffsetOutOfRange);
return WireResult::Success;
}
if (size64 >= WGPU_WHOLE_MAP_SIZE) {
- static constexpr WGPUStringView kSizeOutOfRange = {"Buffer size was out of range.", 29};
- OnBufferMapAsyncCallback(userdata.get(), WGPUMapAsyncStatus_Error, kSizeOutOfRange);
+ OnBufferMapAsyncCallback(userdata.get(), WGPUBufferMapAsyncStatus_SizeOutOfRange);
return WireResult::Success;
}
@@ -103,10 +103,16 @@
userdata->offset = offset;
userdata->size = size;
- mProcs.bufferMapAsync(
- buffer->handle, mode, offset, size,
- {nullptr, WGPUCallbackMode_AllowSpontaneous,
- ForwardToServer2<&Server::OnBufferMapAsyncCallback>, userdata.release(), nullptr});
+ if (userdataCount == 1) {
+ mProcs.bufferMapAsync(buffer->handle, mode, offset, size,
+ ForwardToServer<&Server::OnBufferMapAsyncCallback>,
+ userdata.release());
+ } else {
+ mProcs.bufferMapAsync2(
+ buffer->handle, mode, offset, size,
+ {nullptr, WGPUCallbackMode_AllowSpontaneous,
+ ForwardToServer2<&Server::OnBufferMapAsyncCallback2>, userdata.release(), nullptr});
+ }
return WireResult::Success;
}
@@ -219,9 +225,65 @@
return WireResult::Success;
}
-void Server::OnBufferMapAsyncCallback(MapUserdata* data,
- WGPUMapAsyncStatus status,
- WGPUStringView message) {
+void Server::OnBufferMapAsyncCallback(MapUserdata* data, WGPUBufferMapAsyncStatus status) {
+ // Skip sending the callback if the buffer has already been destroyed.
+ Known<WGPUBuffer> buffer;
+ if (Objects<WGPUBuffer>().Get(data->buffer.id, &buffer) != WireResult::Success ||
+ buffer->generation != data->buffer.generation) {
+ return;
+ }
+
+ bool isRead = data->mode & WGPUMapMode_Read;
+ bool isSuccess = status == WGPUBufferMapAsyncStatus_Success;
+
+ ReturnBufferMapAsyncCallbackCmd cmd = {};
+ cmd.eventManager = data->eventManager;
+ cmd.future = data->future;
+ cmd.status = status;
+ cmd.message = kEmptyOutputStringView;
+ cmd.readDataUpdateInfoLength = 0;
+ cmd.readDataUpdateInfo = nullptr;
+ cmd.userdataCount = 1;
+
+ const void* readData = nullptr;
+ size_t readDataUpdateInfoLength = 0;
+ if (isSuccess) {
+ if (isRead) {
+ // Get the serialization size of the message to initialize ReadHandle data.
+ readData = mProcs.bufferGetConstMappedRange(data->bufferObj, data->offset, data->size);
+ readDataUpdateInfoLength =
+ buffer->readHandle->SizeOfSerializeDataUpdate(data->offset, data->size);
+ cmd.readDataUpdateInfoLength = readDataUpdateInfoLength;
+ } else {
+ DAWN_ASSERT(data->mode & WGPUMapMode_Write);
+ // The in-flight map request returned successfully.
+ buffer->mapWriteState = BufferMapWriteState::Mapped;
+ // Set the target of the WriteHandle to the mapped buffer data.
+ // writeHandle Target always refers to the buffer base address.
+ // but we call getMappedRange exactly with the range of data that is potentially
+ // modified (i.e. we don't want getMappedRange(0, wholeBufferSize) if only a
+ // subset of the buffer is actually mapped) in case the implementation does some
+ // range tracking.
+ buffer->writeHandle->SetTarget(static_cast<uint8_t*>(mProcs.bufferGetMappedRange(
+ data->bufferObj, data->offset, data->size)) -
+ data->offset);
+ }
+ }
+
+ SerializeCommand(cmd, CommandExtension{readDataUpdateInfoLength, [&](char* readHandleBuffer) {
+ if (isSuccess && isRead) {
+ // The in-flight map request returned
+ // successfully.
+ buffer->readHandle->SerializeDataUpdate(
+ readData, data->offset, data->size,
+ readHandleBuffer);
+ }
+ }});
+}
+
+void Server::OnBufferMapAsyncCallback2(MapUserdata* data,
+ WGPUMapAsyncStatus status,
+ WGPUStringView message) {
// Skip sending the callback if the buffer has already been destroyed.
Known<WGPUBuffer> buffer;
if (Objects<WGPUBuffer>().Get(data->buffer.id, &buffer) != WireResult::Success ||
@@ -235,10 +297,11 @@
ReturnBufferMapAsyncCallbackCmd cmd = {};
cmd.eventManager = data->eventManager;
cmd.future = data->future;
- cmd.status = status;
+ cmd.status2 = status;
cmd.message = message;
cmd.readDataUpdateInfoLength = 0;
cmd.readDataUpdateInfo = nullptr;
+ cmd.userdataCount = 2;
const void* readData = nullptr;
size_t readDataUpdateInfoLength = 0;
diff --git a/src/dawn/wire/server/ServerDevice.cpp b/src/dawn/wire/server/ServerDevice.cpp
index dda48bc..f428677 100644
--- a/src/dawn/wire/server/ServerDevice.cpp
+++ b/src/dawn/wire/server/ServerDevice.cpp
@@ -72,9 +72,9 @@
userdata->eventManager = eventManager;
userdata->future = future;
- mProcs.devicePopErrorScope(device->handle, {nullptr, WGPUCallbackMode_AllowProcessEvents,
- ForwardToServer2<&Server::OnDevicePopErrorScope>,
- userdata.release(), nullptr});
+ mProcs.devicePopErrorScope2(device->handle, {nullptr, WGPUCallbackMode_AllowProcessEvents,
+ ForwardToServer2<&Server::OnDevicePopErrorScope>,
+ userdata.release(), nullptr});
return WireResult::Success;
}
@@ -107,7 +107,7 @@
userdata->future = future;
userdata->pipelineObjectID = pipeline.id;
- mProcs.deviceCreateComputePipelineAsync(
+ mProcs.deviceCreateComputePipelineAsync2(
device->handle, descriptor,
{nullptr, WGPUCallbackMode_AllowProcessEvents,
ForwardToServer2<&Server::OnCreateComputePipelineAsyncCallback>, userdata.release(),
@@ -149,7 +149,7 @@
userdata->future = future;
userdata->pipelineObjectID = pipeline.id;
- mProcs.deviceCreateRenderPipelineAsync(
+ mProcs.deviceCreateRenderPipelineAsync2(
device->handle, descriptor,
{nullptr, WGPUCallbackMode_AllowProcessEvents,
ForwardToServer2<&Server::OnCreateRenderPipelineAsyncCallback>, userdata.release(),
diff --git a/src/dawn/wire/server/ServerQueue.cpp b/src/dawn/wire/server/ServerQueue.cpp
index 2eba81a..338a3b5 100644
--- a/src/dawn/wire/server/ServerQueue.cpp
+++ b/src/dawn/wire/server/ServerQueue.cpp
@@ -43,15 +43,22 @@
WireResult Server::DoQueueOnSubmittedWorkDone(Known<WGPUQueue> queue,
ObjectHandle eventManager,
- WGPUFuture future) {
+ WGPUFuture future,
+ uint8_t userdataCount) {
auto userdata = MakeUserdata<QueueWorkDoneUserdata>();
userdata->queue = queue.AsHandle();
userdata->eventManager = eventManager;
userdata->future = future;
- mProcs.queueOnSubmittedWorkDone(
- queue->handle, {nullptr, WGPUCallbackMode_AllowProcessEvents,
- ForwardToServer2<&Server::OnQueueWorkDone>, userdata.release(), nullptr});
+ if (userdataCount == 1) {
+ mProcs.queueOnSubmittedWorkDone(queue->handle, ForwardToServer<&Server::OnQueueWorkDone>,
+ userdata.release());
+ } else {
+ mProcs.queueOnSubmittedWorkDone2(
+ queue->handle,
+ {nullptr, WGPUCallbackMode_AllowProcessEvents,
+ ForwardToServer2<&Server::OnQueueWorkDone>, userdata.release(), nullptr});
+ }
return WireResult::Success;
}
diff --git a/src/dawn/wire/server/ServerShaderModule.cpp b/src/dawn/wire/server/ServerShaderModule.cpp
index 969022b..effb4e0 100644
--- a/src/dawn/wire/server/ServerShaderModule.cpp
+++ b/src/dawn/wire/server/ServerShaderModule.cpp
@@ -38,7 +38,7 @@
userdata->eventManager = eventManager;
userdata->future = future;
- mProcs.shaderModuleGetCompilationInfo(
+ mProcs.shaderModuleGetCompilationInfo2(
shaderModule->handle,
{nullptr, WGPUCallbackMode_AllowProcessEvents,
ForwardToServer2<&Server::OnShaderModuleGetCompilationInfo>, userdata.release(), nullptr});
diff --git a/third_party/emdawnwebgpu/webgpu.cpp b/third_party/emdawnwebgpu/webgpu.cpp
index 8e6d041..1c44642 100644
--- a/third_party/emdawnwebgpu/webgpu.cpp
+++ b/third_party/emdawnwebgpu/webgpu.cpp
@@ -641,7 +641,7 @@
WGPUFuture MapAsync(WGPUMapMode mode,
size_t offset,
size_t size,
- WGPUBufferMapCallbackInfo callbackInfo);
+ WGPUBufferMapCallbackInfo2 callbackInfo);
void Unmap();
private:
@@ -714,7 +714,7 @@
public:
WGPUShaderModuleImpl(const EventSource* source);
- WGPUFuture GetCompilationInfo(WGPUCompilationInfoCallbackInfo callbackInfo);
+ WGPUFuture GetCompilationInfo(WGPUCompilationInfoCallbackInfo2 callbackInfo);
private:
friend class CompilationInfoEvent;
@@ -751,7 +751,7 @@
CompilationInfoEvent(InstanceID instance,
WGPUShaderModule shader,
- const WGPUCompilationInfoCallbackInfo& callbackInfo)
+ const WGPUCompilationInfoCallbackInfo2& callbackInfo)
: TrackedEvent(instance, callbackInfo.mode),
mCallback(callbackInfo.callback),
mUserdata1(callbackInfo.userdata1),
@@ -789,7 +789,7 @@
}
private:
- WGPUCompilationInfoCallback mCallback = nullptr;
+ WGPUCompilationInfoCallback2 mCallback = nullptr;
void* mUserdata1 = nullptr;
void* mUserdata2 = nullptr;
@@ -848,11 +848,11 @@
using CreateComputePipelineEvent =
CreatePipelineEventBase<WGPUComputePipeline,
EventType::CreateComputePipeline,
- WGPUCreateComputePipelineAsyncCallbackInfo>;
+ WGPUCreateComputePipelineAsyncCallbackInfo2>;
using CreateRenderPipelineEvent =
CreatePipelineEventBase<WGPURenderPipeline,
EventType::CreateRenderPipeline,
- WGPUCreateRenderPipelineAsyncCallbackInfo>;
+ WGPUCreateRenderPipelineAsyncCallbackInfo2>;
class DeviceLostEvent final : public TrackedEvent {
public:
@@ -908,7 +908,7 @@
static constexpr EventType kType = EventType::PopErrorScope;
PopErrorScopeEvent(InstanceID instance,
- const WGPUPopErrorScopeCallbackInfo& callbackInfo)
+ const WGPUPopErrorScopeCallbackInfo2& callbackInfo)
: TrackedEvent(instance, callbackInfo.mode),
mCallback(callbackInfo.callback),
mUserdata1(callbackInfo.userdata1),
@@ -939,7 +939,7 @@
}
private:
- WGPUPopErrorScopeCallback mCallback = nullptr;
+ WGPUPopErrorScopeCallback2 mCallback = nullptr;
void* mUserdata1 = nullptr;
void* mUserdata2 = nullptr;
@@ -954,7 +954,7 @@
MapAsyncEvent(InstanceID instance,
WGPUBuffer buffer,
- const WGPUBufferMapCallbackInfo& callbackInfo)
+ const WGPUBufferMapCallbackInfo2& callbackInfo)
: TrackedEvent(instance, callbackInfo.mode),
mCallback(callbackInfo.callback),
mUserdata1(callbackInfo.userdata1),
@@ -1001,7 +1001,7 @@
}
private:
- WGPUBufferMapCallback mCallback = nullptr;
+ WGPUBufferMapCallback2 mCallback = nullptr;
void* mUserdata1 = nullptr;
void* mUserdata2 = nullptr;
@@ -1109,7 +1109,7 @@
static constexpr EventType kType = EventType::WorkDone;
WorkDoneEvent(InstanceID instance,
- const WGPUQueueWorkDoneCallbackInfo& callbackInfo)
+ const WGPUQueueWorkDoneCallbackInfo2& callbackInfo)
: TrackedEvent(instance, callbackInfo.mode),
mCallback(callbackInfo.callback),
mUserdata1(callbackInfo.userdata1),
@@ -1129,7 +1129,7 @@
}
private:
- WGPUQueueWorkDoneCallback mCallback = nullptr;
+ WGPUQueueWorkDoneCallback2 mCallback = nullptr;
void* mUserdata1 = nullptr;
void* mUserdata2 = nullptr;
@@ -1306,7 +1306,7 @@
WGPUFuture WGPUBufferImpl::MapAsync(WGPUMapMode mode,
size_t offset,
size_t size,
- WGPUBufferMapCallbackInfo callbackInfo) {
+ WGPUBufferMapCallbackInfo2 callbackInfo) {
auto [futureId, tracked] = GetEventManager().TrackEvent(
std::make_unique<MapAsyncEvent>(GetInstanceId(), this, callbackInfo));
if (!tracked) {
@@ -1450,7 +1450,7 @@
: EventSource(source) {}
WGPUFuture WGPUShaderModuleImpl::GetCompilationInfo(
- WGPUCompilationInfoCallbackInfo callbackInfo) {
+ WGPUCompilationInfoCallbackInfo2 callbackInfo) {
auto [futureId, tracked] =
GetEventManager().TrackEvent(std::make_unique<CompilationInfoEvent>(
GetInstanceId(), this, callbackInfo));
@@ -1612,11 +1612,11 @@
return buffer->GetMappedRange(offset, size);
}
-WGPUFuture wgpuBufferMapAsync(WGPUBuffer buffer,
- WGPUMapMode mode,
- size_t offset,
- size_t size,
- WGPUBufferMapCallbackInfo callbackInfo) {
+WGPUFuture wgpuBufferMapAsync2(WGPUBuffer buffer,
+ WGPUMapMode mode,
+ size_t offset,
+ size_t size,
+ WGPUBufferMapCallbackInfo2 callbackInfo) {
return buffer->MapAsync(mode, offset, size, callbackInfo);
}
@@ -1651,10 +1651,29 @@
return buffer;
}
-WGPUFuture wgpuDeviceCreateComputePipelineAsync(
+void wgpuDeviceCreateComputePipelineAsync(
WGPUDevice device,
const WGPUComputePipelineDescriptor* descriptor,
- WGPUCreateComputePipelineAsyncCallbackInfo callbackInfo) {
+ WGPUCreateComputePipelineAsyncCallback callback,
+ void* userdata) {
+ WGPUCreateComputePipelineAsyncCallbackInfo2 callbackInfo = {};
+ callbackInfo.mode = WGPUCallbackMode_AllowSpontaneous;
+ callbackInfo.callback =
+ [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline,
+ WGPUStringView message, void* callback, void* userdata) {
+ auto cb =
+ reinterpret_cast<WGPUCreateComputePipelineAsyncCallback>(callback);
+ cb(status, pipeline, message, userdata);
+ };
+ callbackInfo.userdata1 = reinterpret_cast<void*>(callback);
+ callbackInfo.userdata2 = userdata;
+ wgpuDeviceCreateComputePipelineAsync2(device, descriptor, callbackInfo);
+}
+
+WGPUFuture wgpuDeviceCreateComputePipelineAsync2(
+ WGPUDevice device,
+ const WGPUComputePipelineDescriptor* descriptor,
+ WGPUCreateComputePipelineAsyncCallbackInfo2 callbackInfo) {
auto [futureId, tracked] =
GetEventManager().TrackEvent(std::make_unique<CreateComputePipelineEvent>(
device->GetInstanceId(), callbackInfo));
@@ -1666,10 +1685,29 @@
return WGPUFuture{futureId};
}
-WGPUFuture wgpuDeviceCreateRenderPipelineAsync(
+void wgpuDeviceCreateRenderPipelineAsync(
WGPUDevice device,
const WGPURenderPipelineDescriptor* descriptor,
- WGPUCreateRenderPipelineAsyncCallbackInfo callbackInfo) {
+ WGPUCreateRenderPipelineAsyncCallback callback,
+ void* userdata) {
+ WGPUCreateRenderPipelineAsyncCallbackInfo2 callbackInfo = {};
+ callbackInfo.mode = WGPUCallbackMode_AllowSpontaneous;
+ callbackInfo.callback = [](WGPUCreatePipelineAsyncStatus status,
+ WGPURenderPipeline pipeline,
+ WGPUStringView message, void* callback,
+ void* userdata) {
+ auto cb = reinterpret_cast<WGPUCreateRenderPipelineAsyncCallback>(callback);
+ cb(status, pipeline, message, userdata);
+ };
+ callbackInfo.userdata1 = reinterpret_cast<void*>(callback);
+ callbackInfo.userdata2 = userdata;
+ wgpuDeviceCreateRenderPipelineAsync2(device, descriptor, callbackInfo);
+}
+
+WGPUFuture wgpuDeviceCreateRenderPipelineAsync2(
+ WGPUDevice device,
+ const WGPURenderPipelineDescriptor* descriptor,
+ WGPUCreateRenderPipelineAsyncCallbackInfo2 callbackInfo) {
auto [futureId, tracked] =
GetEventManager().TrackEvent(std::make_unique<CreateRenderPipelineEvent>(
device->GetInstanceId(), callbackInfo));
@@ -1701,8 +1739,9 @@
return device->GetQueue();
}
-WGPUFuture wgpuDevicePopErrorScope(WGPUDevice device,
- WGPUPopErrorScopeCallbackInfo callbackInfo) {
+WGPUFuture wgpuDevicePopErrorScope2(
+ WGPUDevice device,
+ WGPUPopErrorScopeCallbackInfo2 callbackInfo) {
auto [futureId, tracked] =
GetEventManager().TrackEvent(std::make_unique<PopErrorScopeEvent>(
device->GetInstanceId(), callbackInfo));
@@ -1773,9 +1812,9 @@
// Methods of Queue
// ----------------------------------------------------------------------------
-WGPUFuture wgpuQueueOnSubmittedWorkDone(
+WGPUFuture wgpuQueueOnSubmittedWorkDone2(
WGPUQueue queue,
- WGPUQueueWorkDoneCallbackInfo callbackInfo) {
+ WGPUQueueWorkDoneCallbackInfo2 callbackInfo) {
auto [futureId, tracked] = GetEventManager().TrackEvent(
std::make_unique<WorkDoneEvent>(queue->GetInstanceId(), callbackInfo));
if (!tracked) {
@@ -1810,9 +1849,9 @@
// Methods of ShaderModule
// ----------------------------------------------------------------------------
-WGPUFuture wgpuShaderModuleGetCompilationInfo(
+WGPUFuture wgpuShaderModuleGetCompilationInfo2(
WGPUShaderModule shader,
- WGPUCompilationInfoCallbackInfo callbackInfo) {
+ WGPUCompilationInfoCallbackInfo2 callbackInfo) {
return shader->GetCompilationInfo(callbackInfo);
}
diff --git a/tools/android/BUILD.gn b/tools/android/BUILD.gn
index de900b1..0e7abd8 100644
--- a/tools/android/BUILD.gn
+++ b/tools/android/BUILD.gn
@@ -62,8 +62,11 @@
"java/android/dawn/BufferBindingLayout.kt",
"java/android/dawn/BufferBindingType.kt",
"java/android/dawn/BufferDescriptor.kt",
+ "java/android/dawn/BufferMapAsyncStatus.kt",
"java/android/dawn/BufferMapCallback.kt",
+ "java/android/dawn/BufferMapCallback2.kt",
"java/android/dawn/BufferMapCallbackInfo.kt",
+ "java/android/dawn/BufferMapCallbackInfo2.kt",
"java/android/dawn/BufferMapState.kt",
"java/android/dawn/BufferUsage.kt",
"java/android/dawn/CallbackMode.kt",
@@ -77,7 +80,9 @@
"java/android/dawn/CompareFunction.kt",
"java/android/dawn/CompilationInfo.kt",
"java/android/dawn/CompilationInfoCallback.kt",
+ "java/android/dawn/CompilationInfoCallback2.kt",
"java/android/dawn/CompilationInfoCallbackInfo.kt",
+ "java/android/dawn/CompilationInfoCallbackInfo2.kt",
"java/android/dawn/CompilationInfoRequestStatus.kt",
"java/android/dawn/CompilationMessage.kt",
"java/android/dawn/CompilationMessageType.kt",
@@ -91,10 +96,14 @@
"java/android/dawn/ConstantEntry.kt",
"java/android/dawn/Constants.kt",
"java/android/dawn/CreateComputePipelineAsyncCallback.kt",
+ "java/android/dawn/CreateComputePipelineAsyncCallback2.kt",
"java/android/dawn/CreateComputePipelineAsyncCallbackInfo.kt",
+ "java/android/dawn/CreateComputePipelineAsyncCallbackInfo2.kt",
"java/android/dawn/CreatePipelineAsyncStatus.kt",
"java/android/dawn/CreateRenderPipelineAsyncCallback.kt",
+ "java/android/dawn/CreateRenderPipelineAsyncCallback2.kt",
"java/android/dawn/CreateRenderPipelineAsyncCallbackInfo.kt",
+ "java/android/dawn/CreateRenderPipelineAsyncCallbackInfo2.kt",
"java/android/dawn/CullMode.kt",
"java/android/dawn/DepthStencilState.kt",
"java/android/dawn/Device.kt",
@@ -134,7 +143,9 @@
"java/android/dawn/PipelineLayout.kt",
"java/android/dawn/PipelineLayoutDescriptor.kt",
"java/android/dawn/PopErrorScopeCallback.kt",
+ "java/android/dawn/PopErrorScopeCallback2.kt",
"java/android/dawn/PopErrorScopeCallbackInfo.kt",
+ "java/android/dawn/PopErrorScopeCallbackInfo2.kt",
"java/android/dawn/PopErrorScopeStatus.kt",
"java/android/dawn/PowerPreference.kt",
"java/android/dawn/PresentMode.kt",
@@ -147,7 +158,9 @@
"java/android/dawn/Queue.kt",
"java/android/dawn/QueueDescriptor.kt",
"java/android/dawn/QueueWorkDoneCallback.kt",
+ "java/android/dawn/QueueWorkDoneCallback2.kt",
"java/android/dawn/QueueWorkDoneCallbackInfo.kt",
+ "java/android/dawn/QueueWorkDoneCallbackInfo2.kt",
"java/android/dawn/QueueWorkDoneStatus.kt",
"java/android/dawn/RenderBundle.kt",
"java/android/dawn/RenderBundleDescriptor.kt",
diff --git a/tools/android/webgpu/src/test/java/android/dawn/MappedNamedConstantsTest.kt b/tools/android/webgpu/src/test/java/android/dawn/MappedNamedConstantsTest.kt
index 886ca44..be7a490 100644
--- a/tools/android/webgpu/src/test/java/android/dawn/MappedNamedConstantsTest.kt
+++ b/tools/android/webgpu/src/test/java/android/dawn/MappedNamedConstantsTest.kt
@@ -21,6 +21,7 @@
BlendFactor::class,
BlendOperation::class,
BufferBindingType::class,
+ BufferMapAsyncStatus::class,
BufferMapState::class,
BufferUsage::class,
CallbackMode::class,
