Make dawn_wire use the webgpu.h header
BUG=dawn:22
Change-Id: I4963aa27322086e74947a1a6265c921e2c7d3d85
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/12700
Reviewed-by: Austin Eng <enga@chromium.org>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
diff --git a/BUILD.gn b/BUILD.gn
index b9a2ac3..617f58d 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -821,7 +821,6 @@
"src/tests/unittests/wire/WireArgumentTests.cpp",
"src/tests/unittests/wire/WireBasicTests.cpp",
"src/tests/unittests/wire/WireBufferMappingTests.cpp",
- "src/tests/unittests/wire/WireDawnDevicePropertiesTests.cpp",
"src/tests/unittests/wire/WireErrorCallbackTests.cpp",
"src/tests/unittests/wire/WireFenceTests.cpp",
"src/tests/unittests/wire/WireInjectTextureTests.cpp",
@@ -829,6 +828,7 @@
"src/tests/unittests/wire/WireOptionalTests.cpp",
"src/tests/unittests/wire/WireTest.cpp",
"src/tests/unittests/wire/WireTest.h",
+ "src/tests/unittests/wire/WireWGPUDevicePropertiesTests.cpp",
]
if (dawn_enable_d3d12) {
diff --git a/generator/dawn_json_generator.py b/generator/dawn_json_generator.py
index f789455..e9428bb 100644
--- a/generator/dawn_json_generator.py
+++ b/generator/dawn_json_generator.py
@@ -458,7 +458,7 @@
if typ.category == 'object':
return typ.name.CamelCase() + '*'
elif typ.category in ['bitmask', 'enum']:
- return 'Dawn' + typ.name.CamelCase()
+ return 'WGPU' + typ.name.CamelCase()
else:
return as_cppType(typ.name)
diff --git a/generator/templates/dawn_wire/WireCmd.cpp b/generator/templates/dawn_wire/WireCmd.cpp
index af7812a..c001e46 100644
--- a/generator/templates/dawn_wire/WireCmd.cpp
+++ b/generator/templates/dawn_wire/WireCmd.cpp
@@ -456,13 +456,13 @@
{{ write_command_serialization_methods(command, True) }}
{% endfor %}
- // Implementations of serialization/deserialization of DawnDeviceProperties.
- size_t SerializedWGPUDevicePropertiesSize(const DawnDeviceProperties* deviceProperties) {
- return sizeof(DawnDeviceProperties) +
+ // Implementations of serialization/deserialization of WPGUDeviceProperties.
+ size_t SerializedWGPUDevicePropertiesSize(const WGPUDeviceProperties* deviceProperties) {
+ return sizeof(WGPUDeviceProperties) +
WGPUDevicePropertiesGetExtraRequiredSize(*deviceProperties);
}
- void SerializeWGPUDeviceProperties(const DawnDeviceProperties* deviceProperties,
+ void SerializeWGPUDeviceProperties(const WGPUDeviceProperties* deviceProperties,
char* serializeBuffer) {
size_t devicePropertiesSize = SerializedWGPUDevicePropertiesSize(deviceProperties);
WGPUDevicePropertiesTransfer* transfer =
@@ -472,7 +472,7 @@
WGPUDevicePropertiesSerialize(*deviceProperties, transfer, &serializeBuffer);
}
- bool DeserializeWGPUDeviceProperties(DawnDeviceProperties* deviceProperties,
+ bool DeserializeWGPUDeviceProperties(WGPUDeviceProperties* deviceProperties,
const volatile char* deserializeBuffer) {
size_t devicePropertiesSize = SerializedWGPUDevicePropertiesSize(deviceProperties);
const volatile WGPUDevicePropertiesTransfer* transfer = nullptr;
diff --git a/generator/templates/dawn_wire/WireCmd.h b/generator/templates/dawn_wire/WireCmd.h
index 7d80b03..0b79acf 100644
--- a/generator/templates/dawn_wire/WireCmd.h
+++ b/generator/templates/dawn_wire/WireCmd.h
@@ -15,7 +15,7 @@
#ifndef DAWNWIRE_WIRECMD_AUTOGEN_H_
#define DAWNWIRE_WIRECMD_AUTOGEN_H_
-#include <dawn/dawn.h>
+#include <dawn/webgpu.h>
namespace dawn_wire {
diff --git a/generator/templates/dawn_wire/client/ApiProcs.cpp b/generator/templates/dawn_wire/client/ApiProcs.cpp
index b93e144..1b12552 100644
--- a/generator/templates/dawn_wire/client/ApiProcs.cpp
+++ b/generator/templates/dawn_wire/client/ApiProcs.cpp
@@ -95,18 +95,18 @@
namespace {
struct ProcEntry {
- DawnProc proc;
+ WGPUProc proc;
const char* name;
};
static const ProcEntry sProcMap[] = {
{% for (type, method) in methods_sorted_by_name %}
- { reinterpret_cast<DawnProc>(Client{{as_MethodSuffix(type.name, method.name)}}), "{{as_cMethod(type.name, method.name)}}" },
+ { reinterpret_cast<WGPUProc>(Client{{as_MethodSuffix(type.name, method.name)}}), "{{as_cMethod(type.name, method.name)}}" },
{% endfor %}
};
static constexpr size_t sProcMapSize = sizeof(sProcMap) / sizeof(sProcMap[0]);
} // anonymous namespace
- DawnProc ClientGetProcAddress(DawnDevice, const char* procName) {
+ WGPUProc ClientGetProcAddress(WGPUDevice, const char* procName) {
if (procName == nullptr) {
return nullptr;
}
@@ -122,7 +122,7 @@
}
if (strcmp(procName, "wgpuGetProcAddress") == 0) {
- return reinterpret_cast<DawnProc>(ClientGetProcAddress);
+ return reinterpret_cast<WGPUProc>(ClientGetProcAddress);
}
return nullptr;
diff --git a/generator/templates/dawn_wire/client/ApiProcs.h b/generator/templates/dawn_wire/client/ApiProcs.h
index 3eedc34..69a183f 100644
--- a/generator/templates/dawn_wire/client/ApiProcs.h
+++ b/generator/templates/dawn_wire/client/ApiProcs.h
@@ -15,7 +15,7 @@
#ifndef DAWNWIRE_CLIENT_APIPROCS_AUTOGEN_H_
#define DAWNWIRE_CLIENT_APIPROCS_AUTOGEN_H_
-#include <dawn/dawn.h>
+#include <dawn/webgpu.h>
namespace dawn_wire { namespace client {
diff --git a/src/dawn_wire/WireClient.cpp b/src/dawn_wire/WireClient.cpp
index 0cbbcd6..ac0a25a 100644
--- a/src/dawn_wire/WireClient.cpp
+++ b/src/dawn_wire/WireClient.cpp
@@ -25,7 +25,7 @@
mImpl.reset();
}
- DawnDevice WireClient::GetDevice() const {
+ WGPUDevice WireClient::GetDevice() const {
return mImpl->GetDevice();
}
@@ -37,7 +37,7 @@
return mImpl->HandleCommands(commands, size);
}
- ReservedTexture WireClient::ReserveTexture(DawnDevice device) {
+ ReservedTexture WireClient::ReserveTexture(WGPUDevice device) {
return mImpl->ReserveTexture(device);
}
@@ -45,12 +45,12 @@
MemoryTransferService::~MemoryTransferService() = default;
MemoryTransferService::ReadHandle*
- MemoryTransferService::CreateReadHandle(DawnBuffer buffer, uint64_t offset, size_t size) {
+ MemoryTransferService::CreateReadHandle(WGPUBuffer buffer, uint64_t offset, size_t size) {
return CreateReadHandle(size);
}
MemoryTransferService::WriteHandle*
- MemoryTransferService::CreateWriteHandle(DawnBuffer buffer, uint64_t offset, size_t size) {
+ MemoryTransferService::CreateWriteHandle(WGPUBuffer buffer, uint64_t offset, size_t size) {
return CreateWriteHandle(size);
}
diff --git a/src/dawn_wire/WireServer.cpp b/src/dawn_wire/WireServer.cpp
index 1896647..11ed424 100644
--- a/src/dawn_wire/WireServer.cpp
+++ b/src/dawn_wire/WireServer.cpp
@@ -32,7 +32,7 @@
return mImpl->HandleCommands(commands, size);
}
- bool WireServer::InjectTexture(DawnTexture texture, uint32_t id, uint32_t generation) {
+ bool WireServer::InjectTexture(WGPUTexture texture, uint32_t id, uint32_t generation) {
return mImpl->InjectTexture(texture, id, generation);
}
diff --git a/src/dawn_wire/client/ApiProcs.cpp b/src/dawn_wire/client/ApiProcs.cpp
index 12ecf89..14f25e4 100644
--- a/src/dawn_wire/client/ApiProcs.cpp
+++ b/src/dawn_wire/client/ApiProcs.cpp
@@ -46,8 +46,8 @@
}
} // namespace
- void ClientBufferMapReadAsync(DawnBuffer cBuffer,
- DawnBufferMapReadCallback callback,
+ void ClientBufferMapReadAsync(WGPUBuffer cBuffer,
+ WGPUBufferMapReadCallback callback,
void* userdata) {
Buffer* buffer = reinterpret_cast<Buffer*>(cBuffer);
@@ -59,7 +59,7 @@
MemoryTransferService::ReadHandle* readHandle =
buffer->device->GetClient()->GetMemoryTransferService()->CreateReadHandle(buffer->size);
if (readHandle == nullptr) {
- callback(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, nullptr, 0, userdata);
+ callback(WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0, userdata);
return;
}
@@ -76,8 +76,8 @@
SerializeBufferMapAsync(buffer, serial, readHandle);
}
- void ClientBufferMapWriteAsync(DawnBuffer cBuffer,
- DawnBufferMapWriteCallback callback,
+ void ClientBufferMapWriteAsync(WGPUBuffer cBuffer,
+ WGPUBufferMapWriteCallback callback,
void* userdata) {
Buffer* buffer = reinterpret_cast<Buffer*>(cBuffer);
@@ -90,7 +90,7 @@
buffer->device->GetClient()->GetMemoryTransferService()->CreateWriteHandle(
buffer->size);
if (writeHandle == nullptr) {
- callback(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, nullptr, 0, userdata);
+ callback(WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0, userdata);
return;
}
@@ -107,8 +107,8 @@
SerializeBufferMapAsync(buffer, serial, writeHandle);
}
- DawnBuffer ClientDeviceCreateBuffer(DawnDevice cDevice,
- const DawnBufferDescriptor* descriptor) {
+ WGPUBuffer ClientDeviceCreateBuffer(WGPUDevice cDevice,
+ const WGPUBufferDescriptor* descriptor) {
Device* device = reinterpret_cast<Device*>(cDevice);
Client* wireClient = device->GetClient();
@@ -127,12 +127,12 @@
char* allocatedBuffer = static_cast<char*>(wireClient->GetCmdSpace(requiredSize));
cmd.Serialize(allocatedBuffer, *wireClient);
- return reinterpret_cast<DawnBuffer>(buffer);
+ return reinterpret_cast<WGPUBuffer>(buffer);
}
- DawnCreateBufferMappedResult ClientDeviceCreateBufferMapped(
- DawnDevice cDevice,
- const DawnBufferDescriptor* descriptor) {
+ WGPUCreateBufferMappedResult ClientDeviceCreateBufferMapped(
+ WGPUDevice cDevice,
+ const WGPUBufferDescriptor* descriptor) {
Device* device = reinterpret_cast<Device*>(cDevice);
Client* wireClient = device->GetClient();
@@ -140,8 +140,8 @@
Buffer* buffer = bufferObjectAndSerial->object.get();
buffer->size = descriptor->size;
- DawnCreateBufferMappedResult result;
- result.buffer = reinterpret_cast<DawnBuffer>(buffer);
+ WGPUCreateBufferMappedResult result;
+ result.buffer = reinterpret_cast<WGPUBuffer>(buffer);
result.data = nullptr;
result.dataLength = 0;
@@ -190,9 +190,9 @@
return result;
}
- void ClientDeviceCreateBufferMappedAsync(DawnDevice cDevice,
- const DawnBufferDescriptor* descriptor,
- DawnBufferCreateMappedCallback callback,
+ void ClientDeviceCreateBufferMappedAsync(WGPUDevice cDevice,
+ const WGPUBufferDescriptor* descriptor,
+ WGPUBufferCreateMappedCallback callback,
void* userdata) {
Device* device = reinterpret_cast<Device*>(cDevice);
Client* wireClient = device->GetClient();
@@ -204,13 +204,13 @@
uint32_t serial = buffer->requestSerial++;
struct CreateBufferMappedInfo {
- DawnBuffer buffer;
- DawnBufferCreateMappedCallback callback;
+ WGPUBuffer buffer;
+ WGPUBufferCreateMappedCallback callback;
void* userdata;
};
CreateBufferMappedInfo* info = new CreateBufferMappedInfo;
- info->buffer = reinterpret_cast<DawnBuffer>(buffer);
+ info->buffer = reinterpret_cast<WGPUBuffer>(buffer);
info->callback = callback;
info->userdata = userdata;
@@ -219,21 +219,21 @@
MemoryTransferService::WriteHandle* writeHandle =
wireClient->GetMemoryTransferService()->CreateWriteHandle(descriptor->size);
if (writeHandle == nullptr) {
- DawnCreateBufferMappedResult result;
- result.buffer = reinterpret_cast<DawnBuffer>(buffer);
+ WGPUCreateBufferMappedResult result;
+ result.buffer = reinterpret_cast<WGPUBuffer>(buffer);
result.data = nullptr;
result.dataLength = 0;
- callback(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, result, userdata);
+ callback(WGPUBufferMapAsyncStatus_DeviceLost, result, userdata);
return;
}
Buffer::MapRequestData request;
- request.writeCallback = [](DawnBufferMapAsyncStatus status, void* data, uint64_t dataLength,
+ request.writeCallback = [](WGPUBufferMapAsyncStatus status, void* data, uint64_t dataLength,
void* userdata) {
auto info = std::unique_ptr<CreateBufferMappedInfo>(
static_cast<CreateBufferMappedInfo*>(userdata));
- DawnCreateBufferMappedResult result;
+ WGPUCreateBufferMappedResult result;
result.buffer = info->buffer;
result.data = data;
result.dataLength = dataLength;
@@ -264,36 +264,36 @@
writeHandle->SerializeCreate(allocatedBuffer + commandSize);
}
- void ClientDevicePushErrorScope(DawnDevice cDevice, DawnErrorFilter filter) {
+ void ClientDevicePushErrorScope(WGPUDevice cDevice, WGPUErrorFilter filter) {
Device* device = reinterpret_cast<Device*>(cDevice);
device->PushErrorScope(filter);
}
- bool ClientDevicePopErrorScope(DawnDevice cDevice, DawnErrorCallback callback, void* userdata) {
+ bool ClientDevicePopErrorScope(WGPUDevice cDevice, WGPUErrorCallback callback, void* userdata) {
Device* device = reinterpret_cast<Device*>(cDevice);
return device->RequestPopErrorScope(callback, userdata);
}
- uint64_t ClientFenceGetCompletedValue(DawnFence cSelf) {
+ uint64_t ClientFenceGetCompletedValue(WGPUFence cSelf) {
auto fence = reinterpret_cast<Fence*>(cSelf);
return fence->completedValue;
}
- void ClientFenceOnCompletion(DawnFence cFence,
+ void ClientFenceOnCompletion(WGPUFence cFence,
uint64_t value,
- DawnFenceOnCompletionCallback callback,
+ WGPUFenceOnCompletionCallback callback,
void* userdata) {
Fence* fence = reinterpret_cast<Fence*>(cFence);
if (value > fence->signaledValue) {
- ClientDeviceInjectError(reinterpret_cast<DawnDevice>(fence->device),
- DAWN_ERROR_TYPE_VALIDATION,
+ ClientDeviceInjectError(reinterpret_cast<WGPUDevice>(fence->device),
+ WGPUErrorType_Validation,
"Value greater than fence signaled value");
- callback(DAWN_FENCE_COMPLETION_STATUS_ERROR, userdata);
+ callback(WGPUFenceCompletionStatus_Error, userdata);
return;
}
if (value <= fence->completedValue) {
- callback(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, userdata);
+ callback(WGPUFenceCompletionStatus_Success, userdata);
return;
}
@@ -303,7 +303,7 @@
fence->requests.Enqueue(std::move(request), value);
}
- void ClientBufferSetSubData(DawnBuffer cBuffer,
+ void ClientBufferSetSubData(WGPUBuffer cBuffer,
uint64_t start,
uint64_t count,
const void* data) {
@@ -321,7 +321,7 @@
cmd.Serialize(allocatedBuffer);
}
- void ClientBufferUnmap(DawnBuffer cBuffer) {
+ void ClientBufferUnmap(WGPUBuffer cBuffer) {
Buffer* buffer = reinterpret_cast<Buffer*>(cBuffer);
// Invalidate the local pointer, and cancel all other in-flight requests that would
@@ -358,7 +358,7 @@
} else if (buffer->readHandle) {
buffer->readHandle = nullptr;
}
- buffer->ClearMapRequests(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN);
+ buffer->ClearMapRequests(WGPUBufferMapAsyncStatus_Unknown);
BufferUnmapCmd cmd;
cmd.self = cBuffer;
@@ -368,7 +368,7 @@
cmd.Serialize(allocatedBuffer, *buffer->device->GetClient());
}
- DawnFence ClientQueueCreateFence(DawnQueue cSelf, DawnFenceDescriptor const* descriptor) {
+ WGPUFence ClientQueueCreateFence(WGPUQueue cSelf, WGPUFenceDescriptor const* descriptor) {
Queue* queue = reinterpret_cast<Queue*>(cSelf);
Device* device = queue->device;
@@ -382,7 +382,7 @@
char* allocatedBuffer = static_cast<char*>(device->GetClient()->GetCmdSpace(requiredSize));
cmd.Serialize(allocatedBuffer, *device->GetClient());
- DawnFence cFence = reinterpret_cast<DawnFence>(allocation->object.get());
+ WGPUFence cFence = reinterpret_cast<WGPUFence>(allocation->object.get());
Fence* fence = reinterpret_cast<Fence*>(cFence);
fence->queue = queue;
@@ -391,18 +391,18 @@
return cFence;
}
- void ClientQueueSignal(DawnQueue cQueue, DawnFence cFence, uint64_t signalValue) {
+ void ClientQueueSignal(WGPUQueue cQueue, WGPUFence cFence, uint64_t signalValue) {
Fence* fence = reinterpret_cast<Fence*>(cFence);
Queue* queue = reinterpret_cast<Queue*>(cQueue);
if (fence->queue != queue) {
- ClientDeviceInjectError(reinterpret_cast<DawnDevice>(fence->device),
- DAWN_ERROR_TYPE_VALIDATION,
+ ClientDeviceInjectError(reinterpret_cast<WGPUDevice>(fence->device),
+ WGPUErrorType_Validation,
"Fence must be signaled on the queue on which it was created.");
return;
}
if (signalValue <= fence->signaledValue) {
- ClientDeviceInjectError(reinterpret_cast<DawnDevice>(fence->device),
- DAWN_ERROR_TYPE_VALIDATION,
+ ClientDeviceInjectError(reinterpret_cast<WGPUDevice>(fence->device),
+ WGPUErrorType_Validation,
"Fence value less than or equal to signaled value");
return;
}
@@ -419,14 +419,14 @@
cmd.Serialize(allocatedBuffer, *fence->device->GetClient());
}
- void ClientDeviceReference(DawnDevice) {
+ void ClientDeviceReference(WGPUDevice) {
}
- void ClientDeviceRelease(DawnDevice) {
+ void ClientDeviceRelease(WGPUDevice) {
}
- void ClientDeviceSetUncapturedErrorCallback(DawnDevice cSelf,
- DawnErrorCallback callback,
+ void ClientDeviceSetUncapturedErrorCallback(WGPUDevice cSelf,
+ WGPUErrorCallback callback,
void* userdata) {
Device* device = reinterpret_cast<Device*>(cSelf);
device->SetUncapturedErrorCallback(callback, userdata);
diff --git a/src/dawn_wire/client/Buffer.cpp b/src/dawn_wire/client/Buffer.cpp
index 3686277..3548f51 100644
--- a/src/dawn_wire/client/Buffer.cpp
+++ b/src/dawn_wire/client/Buffer.cpp
@@ -19,10 +19,10 @@
Buffer::~Buffer() {
// Callbacks need to be fired in all cases, as they can handle freeing resources
// so we call them with "Unknown" status.
- ClearMapRequests(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN);
+ ClearMapRequests(WGPUBufferMapAsyncStatus_Unknown);
}
- void Buffer::ClearMapRequests(DawnBufferMapAsyncStatus status) {
+ void Buffer::ClearMapRequests(WGPUBufferMapAsyncStatus status) {
for (auto& it : requests) {
if (it.second.writeHandle) {
it.second.writeCallback(status, nullptr, 0, it.second.userdata);
diff --git a/src/dawn_wire/client/Buffer.h b/src/dawn_wire/client/Buffer.h
index aa90d6e..09da8e3 100644
--- a/src/dawn_wire/client/Buffer.h
+++ b/src/dawn_wire/client/Buffer.h
@@ -15,7 +15,7 @@
#ifndef DAWNWIRE_CLIENT_BUFFER_H_
#define DAWNWIRE_CLIENT_BUFFER_H_
-#include <dawn/dawn.h>
+#include <dawn/webgpu.h>
#include "dawn_wire/WireClient.h"
#include "dawn_wire/client/ObjectBase.h"
@@ -28,15 +28,15 @@
using ObjectBase::ObjectBase;
~Buffer();
- void ClearMapRequests(DawnBufferMapAsyncStatus status);
+ void ClearMapRequests(WGPUBufferMapAsyncStatus status);
// We want to defer all the validation to the server, which means we could have multiple
// map request in flight at a single time and need to track them separately.
// On well-behaved applications, only one request should exist at a single time.
struct MapRequestData {
// TODO(enga): Use a tagged pointer to save space.
- DawnBufferMapReadCallback readCallback = nullptr;
- DawnBufferMapWriteCallback writeCallback = nullptr;
+ WGPUBufferMapReadCallback readCallback = nullptr;
+ WGPUBufferMapWriteCallback writeCallback = nullptr;
void* userdata = nullptr;
// TODO(enga): Use a tagged pointer to save space.
std::unique_ptr<MemoryTransferService::ReadHandle> readHandle = nullptr;
diff --git a/src/dawn_wire/client/Client.cpp b/src/dawn_wire/client/Client.cpp
index 8079d49..572086f 100644
--- a/src/dawn_wire/client/Client.cpp
+++ b/src/dawn_wire/client/Client.cpp
@@ -33,12 +33,12 @@
DeviceAllocator().Free(mDevice);
}
- ReservedTexture Client::ReserveTexture(DawnDevice cDevice) {
+ ReservedTexture Client::ReserveTexture(WGPUDevice cDevice) {
Device* device = reinterpret_cast<Device*>(cDevice);
ObjectAllocator<Texture>::ObjectAndSerial* allocation = TextureAllocator().New(device);
ReservedTexture result;
- result.texture = reinterpret_cast<DawnTexture>(allocation->object.get());
+ result.texture = reinterpret_cast<WGPUTexture>(allocation->object.get());
result.id = allocation->object->id;
result.generation = allocation->serial;
return result;
diff --git a/src/dawn_wire/client/Client.h b/src/dawn_wire/client/Client.h
index c1af427..f7d311f 100644
--- a/src/dawn_wire/client/Client.h
+++ b/src/dawn_wire/client/Client.h
@@ -15,7 +15,7 @@
#ifndef DAWNWIRE_CLIENT_CLIENT_H_
#define DAWNWIRE_CLIENT_CLIENT_H_
-#include <dawn/dawn.h>
+#include <dawn/webgpu.h>
#include <dawn_wire/Wire.h>
#include "dawn_wire/WireClient.h"
@@ -34,14 +34,14 @@
~Client();
const volatile char* HandleCommands(const volatile char* commands, size_t size);
- ReservedTexture ReserveTexture(DawnDevice device);
+ ReservedTexture ReserveTexture(WGPUDevice device);
void* GetCmdSpace(size_t size) {
return mSerializer->GetCmdSpace(size);
}
- DawnDevice GetDevice() const {
- return reinterpret_cast<DawnDeviceImpl*>(mDevice);
+ WGPUDevice GetDevice() const {
+ return reinterpret_cast<WGPUDeviceImpl*>(mDevice);
}
MemoryTransferService* GetMemoryTransferService() const {
diff --git a/src/dawn_wire/client/ClientDoers.cpp b/src/dawn_wire/client/ClientDoers.cpp
index 09758ea..1be0f1d 100644
--- a/src/dawn_wire/client/ClientDoers.cpp
+++ b/src/dawn_wire/client/ClientDoers.cpp
@@ -20,13 +20,13 @@
namespace dawn_wire { namespace client {
- bool Client::DoDeviceUncapturedErrorCallback(DawnErrorType errorType, const char* message) {
+ bool Client::DoDeviceUncapturedErrorCallback(WGPUErrorType errorType, const char* message) {
switch (errorType) {
- case DAWN_ERROR_TYPE_NO_ERROR:
- case DAWN_ERROR_TYPE_VALIDATION:
- case DAWN_ERROR_TYPE_OUT_OF_MEMORY:
- case DAWN_ERROR_TYPE_UNKNOWN:
- case DAWN_ERROR_TYPE_DEVICE_LOST:
+ case WGPUErrorType_NoError:
+ case WGPUErrorType_Validation:
+ case WGPUErrorType_OutOfMemory:
+ case WGPUErrorType_Unknown:
+ case WGPUErrorType_DeviceLost:
break;
default:
return false;
@@ -36,7 +36,7 @@
}
bool Client::DoDevicePopErrorScopeCallback(uint64_t requestSerial,
- DawnErrorType errorType,
+ WGPUErrorType errorType,
const char* message) {
return mDevice->PopErrorScope(requestSerial, errorType, message);
}
@@ -71,7 +71,7 @@
return false;
}
- if (status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
+ if (status == WGPUBufferMapAsyncStatus_Success) {
if (buffer->readHandle || buffer->writeHandle) {
// Buffer is already mapped.
return false;
@@ -105,11 +105,10 @@
if (!GetMappedData()) {
// Dawn promises that all callbacks are called in finite time. Even if a fatal error
// occurs, the callback is called.
- request.readCallback(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, nullptr, 0,
- request.userdata);
+ request.readCallback(WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0, request.userdata);
return false;
} else {
- request.readCallback(static_cast<DawnBufferMapAsyncStatus>(status), mappedData,
+ request.readCallback(static_cast<WGPUBufferMapAsyncStatus>(status), mappedData,
static_cast<uint64_t>(mappedDataLength), request.userdata);
return true;
}
@@ -143,7 +142,7 @@
return false;
}
- if (status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
+ if (status == WGPUBufferMapAsyncStatus_Success) {
if (buffer->readHandle || buffer->writeHandle) {
// Buffer is already mapped.
return false;
@@ -169,11 +168,11 @@
if (!GetMappedData()) {
// Dawn promises that all callbacks are called in finite time. Even if a fatal error
// occurs, the callback is called.
- request.writeCallback(DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST, nullptr, 0,
+ request.writeCallback(WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0,
request.userdata);
return false;
} else {
- request.writeCallback(static_cast<DawnBufferMapAsyncStatus>(status), mappedData,
+ request.writeCallback(static_cast<WGPUBufferMapAsyncStatus>(status), mappedData,
static_cast<uint64_t>(mappedDataLength), request.userdata);
return true;
}
diff --git a/src/dawn_wire/client/Device.cpp b/src/dawn_wire/client/Device.cpp
index 7682e1a..8577a4f 100644
--- a/src/dawn_wire/client/Device.cpp
+++ b/src/dawn_wire/client/Device.cpp
@@ -28,7 +28,7 @@
Device::~Device() {
auto errorScopes = std::move(mErrorScopes);
for (const auto& it : errorScopes) {
- it.second.callback(DAWN_ERROR_TYPE_UNKNOWN, "Device destroyed", it.second.userdata);
+ it.second.callback(WGPUErrorType_Unknown, "Device destroyed", it.second.userdata);
}
}
@@ -36,22 +36,22 @@
return mClient;
}
- void Device::HandleError(DawnErrorType errorType, const char* message) {
+ void Device::HandleError(WGPUErrorType errorType, const char* message) {
if (mErrorCallback) {
mErrorCallback(errorType, message, mErrorUserdata);
}
}
- void Device::SetUncapturedErrorCallback(DawnErrorCallback errorCallback, void* errorUserdata) {
+ void Device::SetUncapturedErrorCallback(WGPUErrorCallback errorCallback, void* errorUserdata) {
mErrorCallback = errorCallback;
mErrorUserdata = errorUserdata;
}
- void Device::PushErrorScope(DawnErrorFilter filter) {
+ void Device::PushErrorScope(WGPUErrorFilter filter) {
mErrorScopeStackSize++;
DevicePushErrorScopeCmd cmd;
- cmd.self = reinterpret_cast<DawnDevice>(this);
+ cmd.self = reinterpret_cast<WGPUDevice>(this);
cmd.filter = filter;
Client* wireClient = GetClient();
@@ -60,7 +60,7 @@
cmd.Serialize(allocatedBuffer, *wireClient);
}
- bool Device::RequestPopErrorScope(DawnErrorCallback callback, void* userdata) {
+ bool Device::RequestPopErrorScope(WGPUErrorCallback callback, void* userdata) {
if (mErrorScopeStackSize == 0) {
return false;
}
@@ -72,7 +72,7 @@
mErrorScopes[serial] = {callback, userdata};
DevicePopErrorScopeCmd cmd;
- cmd.device = reinterpret_cast<DawnDevice>(this);
+ cmd.device = reinterpret_cast<WGPUDevice>(this);
cmd.requestSerial = serial;
Client* wireClient = GetClient();
@@ -83,13 +83,13 @@
return true;
}
- bool Device::PopErrorScope(uint64_t requestSerial, DawnErrorType type, const char* message) {
+ bool Device::PopErrorScope(uint64_t requestSerial, WGPUErrorType type, const char* message) {
switch (type) {
- case DAWN_ERROR_TYPE_NO_ERROR:
- case DAWN_ERROR_TYPE_VALIDATION:
- case DAWN_ERROR_TYPE_OUT_OF_MEMORY:
- case DAWN_ERROR_TYPE_UNKNOWN:
- case DAWN_ERROR_TYPE_DEVICE_LOST:
+ case WGPUErrorType_NoError:
+ case WGPUErrorType_Validation:
+ case WGPUErrorType_OutOfMemory:
+ case WGPUErrorType_Unknown:
+ case WGPUErrorType_DeviceLost:
break;
default:
return false;
diff --git a/src/dawn_wire/client/Device.h b/src/dawn_wire/client/Device.h
index 600a1c3..9c1bb2f 100644
--- a/src/dawn_wire/client/Device.h
+++ b/src/dawn_wire/client/Device.h
@@ -15,7 +15,7 @@
#ifndef DAWNWIRE_CLIENT_DEVICE_H_
#define DAWNWIRE_CLIENT_DEVICE_H_
-#include <dawn/dawn.h>
+#include <dawn/webgpu.h>
#include "dawn_wire/client/ObjectBase.h"
@@ -31,16 +31,16 @@
~Device();
Client* GetClient();
- void HandleError(DawnErrorType errorType, const char* message);
- void SetUncapturedErrorCallback(DawnErrorCallback errorCallback, void* errorUserdata);
+ void HandleError(WGPUErrorType errorType, const char* message);
+ void SetUncapturedErrorCallback(WGPUErrorCallback errorCallback, void* errorUserdata);
- void PushErrorScope(DawnErrorFilter filter);
- bool RequestPopErrorScope(DawnErrorCallback callback, void* userdata);
- bool PopErrorScope(uint64_t requestSerial, DawnErrorType type, const char* message);
+ void PushErrorScope(WGPUErrorFilter filter);
+ bool RequestPopErrorScope(WGPUErrorCallback callback, void* userdata);
+ bool PopErrorScope(uint64_t requestSerial, WGPUErrorType type, const char* message);
private:
struct ErrorScopeData {
- DawnErrorCallback callback = nullptr;
+ WGPUErrorCallback callback = nullptr;
void* userdata = nullptr;
};
std::map<uint64_t, ErrorScopeData> mErrorScopes;
@@ -48,7 +48,7 @@
uint64_t mErrorScopeStackSize = 0;
Client* mClient = nullptr;
- DawnErrorCallback mErrorCallback = nullptr;
+ WGPUErrorCallback mErrorCallback = nullptr;
void* mErrorUserdata;
};
diff --git a/src/dawn_wire/client/Fence.cpp b/src/dawn_wire/client/Fence.cpp
index 497b714..607483e 100644
--- a/src/dawn_wire/client/Fence.cpp
+++ b/src/dawn_wire/client/Fence.cpp
@@ -20,14 +20,14 @@
// Callbacks need to be fired in all cases, as they can handle freeing resources
// so we call them with "Unknown" status.
for (auto& request : requests.IterateAll()) {
- request.completionCallback(DAWN_FENCE_COMPLETION_STATUS_UNKNOWN, request.userdata);
+ request.completionCallback(WGPUFenceCompletionStatus_Unknown, request.userdata);
}
requests.Clear();
}
void Fence::CheckPassedFences() {
for (auto& request : requests.IterateUpTo(completedValue)) {
- request.completionCallback(DAWN_FENCE_COMPLETION_STATUS_SUCCESS, request.userdata);
+ request.completionCallback(WGPUFenceCompletionStatus_Success, request.userdata);
}
requests.ClearUpTo(completedValue);
}
diff --git a/src/dawn_wire/client/Fence.h b/src/dawn_wire/client/Fence.h
index d9b5e57..4acde6d 100644
--- a/src/dawn_wire/client/Fence.h
+++ b/src/dawn_wire/client/Fence.h
@@ -15,7 +15,7 @@
#ifndef DAWNWIRE_CLIENT_FENCE_H_
#define DAWNWIRE_CLIENT_FENCE_H_
-#include <dawn/dawn.h>
+#include <dawn/webgpu.h>
#include "common/SerialMap.h"
#include "dawn_wire/client/ObjectBase.h"
@@ -30,7 +30,7 @@
void CheckPassedFences();
struct OnCompletionData {
- DawnFenceOnCompletionCallback completionCallback = nullptr;
+ WGPUFenceOnCompletionCallback completionCallback = nullptr;
void* userdata = nullptr;
};
Queue* queue = nullptr;
diff --git a/src/dawn_wire/client/ObjectBase.h b/src/dawn_wire/client/ObjectBase.h
index b97b040..edf18f6 100644
--- a/src/dawn_wire/client/ObjectBase.h
+++ b/src/dawn_wire/client/ObjectBase.h
@@ -15,7 +15,7 @@
#ifndef DAWNWIRE_CLIENT_OBJECTBASE_H_
#define DAWNWIRE_CLIENT_OBJECTBASE_H_
-#include <dawn/dawn.h>
+#include <dawn/webgpu.h>
namespace dawn_wire { namespace client {
diff --git a/src/dawn_wire/server/ObjectStorage.h b/src/dawn_wire/server/ObjectStorage.h
index 8afb7ea..55d6a09 100644
--- a/src/dawn_wire/server/ObjectStorage.h
+++ b/src/dawn_wire/server/ObjectStorage.h
@@ -41,7 +41,7 @@
enum class BufferMapWriteState { Unmapped, Mapped, MapError };
template <>
- struct ObjectData<DawnBuffer> : public ObjectDataBase<DawnBuffer> {
+ struct ObjectData<WGPUBuffer> : public ObjectDataBase<WGPUBuffer> {
// TODO(enga): Use a tagged pointer to save space.
std::unique_ptr<MemoryTransferService::ReadHandle> readHandle;
std::unique_ptr<MemoryTransferService::WriteHandle> writeHandle;
diff --git a/src/dawn_wire/server/Server.cpp b/src/dawn_wire/server/Server.cpp
index ab56c4e..d03980a 100644
--- a/src/dawn_wire/server/Server.cpp
+++ b/src/dawn_wire/server/Server.cpp
@@ -17,7 +17,7 @@
namespace dawn_wire { namespace server {
- Server::Server(DawnDevice device,
+ Server::Server(WGPUDevice device,
const DawnProcTable& procs,
CommandSerializer* serializer,
MemoryTransferService* memoryTransferService)
@@ -42,8 +42,8 @@
return mSerializer->GetCmdSpace(size);
}
- bool Server::InjectTexture(DawnTexture texture, uint32_t id, uint32_t generation) {
- ObjectData<DawnTexture>* data = TextureObjects().Allocate(id);
+ bool Server::InjectTexture(WGPUTexture texture, uint32_t id, uint32_t generation) {
+ ObjectData<WGPUTexture>* data = TextureObjects().Allocate(id);
if (data == nullptr) {
return false;
}
diff --git a/src/dawn_wire/server/Server.h b/src/dawn_wire/server/Server.h
index 0f901ad..28f4c81 100644
--- a/src/dawn_wire/server/Server.h
+++ b/src/dawn_wire/server/Server.h
@@ -47,7 +47,7 @@
class Server : public ServerBase {
public:
- Server(DawnDevice device,
+ Server(WGPUDevice device,
const DawnProcTable& procs,
CommandSerializer* serializer,
MemoryTransferService* memoryTransferService);
@@ -55,38 +55,38 @@
const volatile char* HandleCommands(const volatile char* commands, size_t size);
- bool InjectTexture(DawnTexture texture, uint32_t id, uint32_t generation);
+ bool InjectTexture(WGPUTexture texture, uint32_t id, uint32_t generation);
private:
void* GetCmdSpace(size_t size);
// Forwarding callbacks
- static void ForwardUncapturedError(DawnErrorType type, const char* message, void* userdata);
- static void ForwardPopErrorScope(DawnErrorType type, const char* message, void* userdata);
- static void ForwardBufferMapReadAsync(DawnBufferMapAsyncStatus status,
+ static void ForwardUncapturedError(WGPUErrorType type, const char* message, void* userdata);
+ static void ForwardPopErrorScope(WGPUErrorType type, const char* message, void* userdata);
+ static void ForwardBufferMapReadAsync(WGPUBufferMapAsyncStatus status,
const void* ptr,
uint64_t dataLength,
void* userdata);
- static void ForwardBufferMapWriteAsync(DawnBufferMapAsyncStatus status,
+ static void ForwardBufferMapWriteAsync(WGPUBufferMapAsyncStatus status,
void* ptr,
uint64_t dataLength,
void* userdata);
- static void ForwardFenceCompletedValue(DawnFenceCompletionStatus status, void* userdata);
+ static void ForwardFenceCompletedValue(WGPUFenceCompletionStatus status, void* userdata);
// Error callbacks
- void OnUncapturedError(DawnErrorType type, const char* message);
- void OnDevicePopErrorScope(DawnErrorType type,
+ void OnUncapturedError(WGPUErrorType type, const char* message);
+ void OnDevicePopErrorScope(WGPUErrorType type,
const char* message,
ErrorScopeUserdata* userdata);
- void OnBufferMapReadAsyncCallback(DawnBufferMapAsyncStatus status,
+ void OnBufferMapReadAsyncCallback(WGPUBufferMapAsyncStatus status,
const void* ptr,
uint64_t dataLength,
MapUserdata* userdata);
- void OnBufferMapWriteAsyncCallback(DawnBufferMapAsyncStatus status,
+ void OnBufferMapWriteAsyncCallback(WGPUBufferMapAsyncStatus status,
void* ptr,
uint64_t dataLength,
MapUserdata* userdata);
- void OnFenceCompletedValueUpdated(DawnFenceCompletionStatus status,
+ void OnFenceCompletedValueUpdated(WGPUFenceCompletionStatus status,
FenceCompletionUserdata* userdata);
#include "dawn_wire/server/ServerPrototypes_autogen.inc"
diff --git a/src/dawn_wire/server/ServerBuffer.cpp b/src/dawn_wire/server/ServerBuffer.cpp
index c969beb..fb871a5 100644
--- a/src/dawn_wire/server/ServerBuffer.cpp
+++ b/src/dawn_wire/server/ServerBuffer.cpp
@@ -92,8 +92,8 @@
return true;
}
- bool Server::DoDeviceCreateBufferMapped(DawnDevice device,
- const DawnBufferDescriptor* descriptor,
+ bool Server::DoDeviceCreateBufferMapped(WGPUDevice device,
+ const WGPUBufferDescriptor* descriptor,
ObjectHandle bufferResult,
uint64_t handleCreateInfoLength,
const uint8_t* handleCreateInfo) {
@@ -109,7 +109,7 @@
}
resultData->serial = bufferResult.serial;
- DawnCreateBufferMappedResult result = mProcs.deviceCreateBufferMapped(device, descriptor);
+ WGPUCreateBufferMappedResult result = mProcs.deviceCreateBufferMapped(device, descriptor);
ASSERT(result.buffer != nullptr);
if (result.data == nullptr && result.dataLength != 0) {
// Non-zero dataLength but null data is used to indicate an allocation error.
@@ -140,8 +140,8 @@
return true;
}
- bool Server::DoDeviceCreateBufferMappedAsync(DawnDevice device,
- const DawnBufferDescriptor* descriptor,
+ bool Server::DoDeviceCreateBufferMappedAsync(WGPUDevice device,
+ const WGPUBufferDescriptor* descriptor,
uint32_t requestSerial,
ObjectHandle bufferResult,
uint64_t handleCreateInfoLength,
@@ -158,8 +158,8 @@
cmd.buffer = ObjectHandle{bufferResult.id, bufferResult.serial};
cmd.requestSerial = requestSerial;
cmd.status = bufferData->mapWriteState == BufferMapWriteState::Mapped
- ? DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS
- : DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR;
+ ? WGPUBufferMapAsyncStatus_Success
+ : WGPUBufferMapAsyncStatus_Error;
size_t requiredSize = cmd.GetRequiredSize();
char* allocatedBuffer = static_cast<char*>(GetCmdSpace(requiredSize));
@@ -223,7 +223,7 @@
static_cast<size_t>(writeFlushInfoLength));
}
- void Server::ForwardBufferMapReadAsync(DawnBufferMapAsyncStatus status,
+ void Server::ForwardBufferMapReadAsync(WGPUBufferMapAsyncStatus status,
const void* ptr,
uint64_t dataLength,
void* userdata) {
@@ -231,7 +231,7 @@
data->server->OnBufferMapReadAsyncCallback(status, ptr, dataLength, data);
}
- void Server::ForwardBufferMapWriteAsync(DawnBufferMapAsyncStatus status,
+ void Server::ForwardBufferMapWriteAsync(WGPUBufferMapAsyncStatus status,
void* ptr,
uint64_t dataLength,
void* userdata) {
@@ -239,7 +239,7 @@
data->server->OnBufferMapWriteAsyncCallback(status, ptr, dataLength, data);
}
- void Server::OnBufferMapReadAsyncCallback(DawnBufferMapAsyncStatus status,
+ void Server::OnBufferMapReadAsyncCallback(WGPUBufferMapAsyncStatus status,
const void* ptr,
uint64_t dataLength,
MapUserdata* userdata) {
@@ -252,7 +252,7 @@
}
size_t initialDataInfoLength = 0;
- if (status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
+ if (status == WGPUBufferMapAsyncStatus_Success) {
// Get the serialization size of the message to initialize ReadHandle data.
initialDataInfoLength = data->readHandle->SerializeInitialDataSize(ptr, dataLength);
} else {
@@ -271,7 +271,7 @@
char* allocatedBuffer = static_cast<char*>(GetCmdSpace(requiredSize));
cmd.Serialize(allocatedBuffer);
- if (status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
+ if (status == WGPUBufferMapAsyncStatus_Success) {
// Serialize the initialization message into the space after the command.
data->readHandle->SerializeInitialData(ptr, dataLength, allocatedBuffer + commandSize);
@@ -281,7 +281,7 @@
}
}
- void Server::OnBufferMapWriteAsyncCallback(DawnBufferMapAsyncStatus status,
+ void Server::OnBufferMapWriteAsyncCallback(WGPUBufferMapAsyncStatus status,
void* ptr,
uint64_t dataLength,
MapUserdata* userdata) {
@@ -302,7 +302,7 @@
char* allocatedBuffer = static_cast<char*>(GetCmdSpace(requiredSize));
cmd.Serialize(allocatedBuffer);
- if (status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
+ if (status == WGPUBufferMapAsyncStatus_Success) {
// The in-flight map request returned successfully.
// Move the WriteHandle so it is owned by the buffer.
bufferData->writeHandle = std::move(data->writeHandle);
diff --git a/src/dawn_wire/server/ServerDevice.cpp b/src/dawn_wire/server/ServerDevice.cpp
index 8713b57..6f27867 100644
--- a/src/dawn_wire/server/ServerDevice.cpp
+++ b/src/dawn_wire/server/ServerDevice.cpp
@@ -16,12 +16,12 @@
namespace dawn_wire { namespace server {
- void Server::ForwardUncapturedError(DawnErrorType type, const char* message, void* userdata) {
+ void Server::ForwardUncapturedError(WGPUErrorType type, const char* message, void* userdata) {
auto server = static_cast<Server*>(userdata);
server->OnUncapturedError(type, message);
}
- void Server::OnUncapturedError(DawnErrorType type, const char* message) {
+ void Server::OnUncapturedError(WGPUErrorType type, const char* message) {
ReturnDeviceUncapturedErrorCallbackCmd cmd;
cmd.type = type;
cmd.message = message;
@@ -31,7 +31,7 @@
cmd.Serialize(allocatedBuffer);
}
- bool Server::DoDevicePopErrorScope(DawnDevice cDevice, uint64_t requestSerial) {
+ bool Server::DoDevicePopErrorScope(WGPUDevice cDevice, uint64_t requestSerial) {
ErrorScopeUserdata* userdata = new ErrorScopeUserdata;
userdata->server = this;
userdata->requestSerial = requestSerial;
@@ -44,12 +44,12 @@
}
// static
- void Server::ForwardPopErrorScope(DawnErrorType type, const char* message, void* userdata) {
+ void Server::ForwardPopErrorScope(WGPUErrorType type, const char* message, void* userdata) {
auto* data = reinterpret_cast<ErrorScopeUserdata*>(userdata);
data->server->OnDevicePopErrorScope(type, message, data);
}
- void Server::OnDevicePopErrorScope(DawnErrorType type,
+ void Server::OnDevicePopErrorScope(WGPUErrorType type,
const char* message,
ErrorScopeUserdata* userdata) {
std::unique_ptr<ErrorScopeUserdata> data{userdata};
diff --git a/src/dawn_wire/server/ServerFence.cpp b/src/dawn_wire/server/ServerFence.cpp
index 79e14c4..de056a1 100644
--- a/src/dawn_wire/server/ServerFence.cpp
+++ b/src/dawn_wire/server/ServerFence.cpp
@@ -18,16 +18,16 @@
namespace dawn_wire { namespace server {
- void Server::ForwardFenceCompletedValue(DawnFenceCompletionStatus status, void* userdata) {
+ void Server::ForwardFenceCompletedValue(WGPUFenceCompletionStatus status, void* userdata) {
auto data = static_cast<FenceCompletionUserdata*>(userdata);
data->server->OnFenceCompletedValueUpdated(status, data);
}
- void Server::OnFenceCompletedValueUpdated(DawnFenceCompletionStatus status,
+ void Server::OnFenceCompletedValueUpdated(WGPUFenceCompletionStatus status,
FenceCompletionUserdata* userdata) {
std::unique_ptr<FenceCompletionUserdata> data(userdata);
- if (status != DAWN_FENCE_COMPLETION_STATUS_SUCCESS) {
+ if (status != WGPUFenceCompletionStatus_Success) {
return;
}
diff --git a/src/dawn_wire/server/ServerQueue.cpp b/src/dawn_wire/server/ServerQueue.cpp
index 1851dda..9ed58b4 100644
--- a/src/dawn_wire/server/ServerQueue.cpp
+++ b/src/dawn_wire/server/ServerQueue.cpp
@@ -17,7 +17,7 @@
namespace dawn_wire { namespace server {
- bool Server::DoQueueSignal(DawnQueue cSelf, DawnFence cFence, uint64_t signalValue) {
+ bool Server::DoQueueSignal(WGPUQueue cSelf, WGPUFence cFence, uint64_t signalValue) {
if (cFence == nullptr) {
return false;
}
diff --git a/src/include/dawn_wire/Wire.h b/src/include/dawn_wire/Wire.h
index fee4a9a..6120f8b 100644
--- a/src/include/dawn_wire/Wire.h
+++ b/src/include/dawn_wire/Wire.h
@@ -17,7 +17,7 @@
#include <cstdint>
-#include "dawn/dawn.h"
+#include "dawn/webgpu.h"
#include "dawn_wire/dawn_wire_export.h"
namespace dawn_wire {
@@ -36,13 +36,13 @@
};
DAWN_WIRE_EXPORT size_t
- SerializedWGPUDevicePropertiesSize(const DawnDeviceProperties* deviceProperties);
+ SerializedWGPUDevicePropertiesSize(const WGPUDeviceProperties* deviceProperties);
DAWN_WIRE_EXPORT void SerializeWGPUDeviceProperties(
- const DawnDeviceProperties* deviceProperties,
+ const WGPUDeviceProperties* deviceProperties,
char* serializeBuffer);
- DAWN_WIRE_EXPORT bool DeserializeWGPUDeviceProperties(DawnDeviceProperties* deviceProperties,
+ DAWN_WIRE_EXPORT bool DeserializeWGPUDeviceProperties(WGPUDeviceProperties* deviceProperties,
const volatile char* deserializeBuffer);
} // namespace dawn_wire
diff --git a/src/include/dawn_wire/WireClient.h b/src/include/dawn_wire/WireClient.h
index 42b1aa6..376151e 100644
--- a/src/include/dawn_wire/WireClient.h
+++ b/src/include/dawn_wire/WireClient.h
@@ -29,7 +29,7 @@
}
struct ReservedTexture {
- DawnTexture texture;
+ WGPUTexture texture;
uint32_t id;
uint32_t generation;
};
@@ -44,12 +44,12 @@
WireClient(const WireClientDescriptor& descriptor);
~WireClient();
- DawnDevice GetDevice() const;
+ WGPUDevice GetDevice() const;
DawnProcTable GetProcs() const;
const volatile char* HandleCommands(const volatile char* commands,
size_t size) override final;
- ReservedTexture ReserveTexture(DawnDevice device);
+ ReservedTexture ReserveTexture(WGPUDevice device);
private:
std::unique_ptr<client::Client> mImpl;
@@ -74,8 +74,8 @@
// Imported memory implementation needs to override these to create Read/Write
// handles associated with a particular buffer. The client should receive a file
// descriptor for the buffer out-of-band.
- virtual ReadHandle* CreateReadHandle(DawnBuffer, uint64_t offset, size_t size);
- virtual WriteHandle* CreateWriteHandle(DawnBuffer, uint64_t offset, size_t size);
+ virtual ReadHandle* CreateReadHandle(WGPUBuffer, uint64_t offset, size_t size);
+ virtual WriteHandle* CreateWriteHandle(WGPUBuffer, uint64_t offset, size_t size);
class DAWN_WIRE_EXPORT ReadHandle {
public:
diff --git a/src/include/dawn_wire/WireServer.h b/src/include/dawn_wire/WireServer.h
index e018b5b..f965a04 100644
--- a/src/include/dawn_wire/WireServer.h
+++ b/src/include/dawn_wire/WireServer.h
@@ -29,7 +29,7 @@
}
struct DAWN_WIRE_EXPORT WireServerDescriptor {
- DawnDevice device;
+ WGPUDevice device;
const DawnProcTable* procs;
CommandSerializer* serializer;
server::MemoryTransferService* memoryTransferService = nullptr;
@@ -43,7 +43,7 @@
const volatile char* HandleCommands(const volatile char* commands,
size_t size) override final;
- bool InjectTexture(DawnTexture texture, uint32_t id, uint32_t generation);
+ bool InjectTexture(WGPUTexture texture, uint32_t id, uint32_t generation);
private:
std::unique_ptr<server::Server> mImpl;
diff --git a/src/tests/unittests/wire/WireDawnDevicePropertiesTests.cpp b/src/tests/unittests/wire/WireDawnDevicePropertiesTests.cpp
deleted file mode 100644
index e445d63..0000000
--- a/src/tests/unittests/wire/WireDawnDevicePropertiesTests.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2019 The Dawn Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "dawn_wire/Wire.h"
-#include "gtest/gtest.h"
-
-#include <vector>
-
-class WireDawnDevicePropertiesTests : public testing::Test {};
-
-// Test that the serialization and deserialization of DawnDeviceProperties can work correctly.
-TEST_F(WireDawnDevicePropertiesTests, SerializeDawnDeviceProperties) {
- DawnDeviceProperties sentDawnDeviceProperties;
- sentDawnDeviceProperties.textureCompressionBC = true;
-
- size_t sentDawnDevicePropertiesSize =
- dawn_wire::SerializedWGPUDevicePropertiesSize(&sentDawnDeviceProperties);
- std::vector<char> buffer;
- buffer.resize(sentDawnDevicePropertiesSize);
- dawn_wire::SerializeWGPUDeviceProperties(&sentDawnDeviceProperties, buffer.data());
-
- DawnDeviceProperties receivedDawnDeviceProperties;
- dawn_wire::DeserializeWGPUDeviceProperties(&receivedDawnDeviceProperties, buffer.data());
- ASSERT_TRUE(receivedDawnDeviceProperties.textureCompressionBC);
-}
diff --git a/src/tests/unittests/wire/WireWGPUDevicePropertiesTests.cpp b/src/tests/unittests/wire/WireWGPUDevicePropertiesTests.cpp
new file mode 100644
index 0000000..70abc2c
--- /dev/null
+++ b/src/tests/unittests/wire/WireWGPUDevicePropertiesTests.cpp
@@ -0,0 +1,36 @@
+// Copyright 2019 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "dawn_wire/Wire.h"
+#include "gtest/gtest.h"
+
+#include <vector>
+
+class WireWGPUDevicePropertiesTests : public testing::Test {};
+
+// Test that the serialization and deserialization of WGPUDeviceProperties can work correctly.
+TEST_F(WireWGPUDevicePropertiesTests, SerializeWGPUDeviceProperties) {
+ WGPUDeviceProperties sentWGPUDeviceProperties;
+ sentWGPUDeviceProperties.textureCompressionBC = true;
+
+ size_t sentWGPUDevicePropertiesSize =
+ dawn_wire::SerializedWGPUDevicePropertiesSize(&sentWGPUDeviceProperties);
+ std::vector<char> buffer;
+ buffer.resize(sentWGPUDevicePropertiesSize);
+ dawn_wire::SerializeWGPUDeviceProperties(&sentWGPUDeviceProperties, buffer.data());
+
+ WGPUDeviceProperties receivedWGPUDeviceProperties;
+ dawn_wire::DeserializeWGPUDeviceProperties(&receivedWGPUDeviceProperties, buffer.data());
+ ASSERT_TRUE(receivedWGPUDeviceProperties.textureCompressionBC);
+}
