dawn::wire::server: Use WireResult consistently for error handling.
This will prevent accidentally forgetting to handle errors since
WireResult is tagged as [[must_use]]. Also it allows using WIRE_TRY()
which is marginally less verbose.
Bug: dawn:1821
Change-Id: I675c4c73d2523411d8da8f08ffedd5c9b4c8201a
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/134680
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Loko Kung <lokokung@google.com>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
diff --git a/generator/templates/dawn/wire/server/ServerBase.h b/generator/templates/dawn/wire/server/ServerBase.h
index 7ca4b3a..02add56 100644
--- a/generator/templates/dawn/wire/server/ServerBase.h
+++ b/generator/templates/dawn/wire/server/ServerBase.h
@@ -71,10 +71,7 @@
// Implementation of the ObjectIdResolver interface
{% for type in by_category["object"] %}
WireResult GetFromId(ObjectId id, {{as_cType(type.name)}}* out) const final {
- if (!mKnown{{type.name.CamelCase()}}.GetNativeHandle(id, out)) {
- return WireResult::FatalError;
- }
- return WireResult::Success;
+ return mKnown{{type.name.CamelCase()}}.GetNativeHandle(id, out);
}
WireResult GetOptionalFromId(ObjectId id, {{as_cType(type.name)}}* out) const final {
diff --git a/generator/templates/dawn/wire/server/ServerDoers.cpp b/generator/templates/dawn/wire/server/ServerDoers.cpp
index 7906556..9d6c32f 100644
--- a/generator/templates/dawn/wire/server/ServerDoers.cpp
+++ b/generator/templates/dawn/wire/server/ServerDoers.cpp
@@ -25,7 +25,7 @@
{% set Suffix = command.name.CamelCase() %}
{% if Suffix not in client_side_commands %}
{% if is_method and Suffix not in server_handwritten_commands %}
- bool Server::Do{{Suffix}}(
+ WireResult Server::Do{{Suffix}}(
{%- for member in command.members -%}
{%- if member.is_return_value -%}
{%- if member.handle_type -%}
@@ -58,25 +58,19 @@
//* object creation functions.
ASSERT(*{{as_varName(ret[0].name)}} != nullptr);
{% endif %}
- return true;
+ return WireResult::Success;
}
{% endif %}
{% endif %}
{% endfor %}
- bool Server::DoDestroyObject(ObjectType objectType, ObjectId objectId) {
- //* ID 0 are reserved for nullptr and cannot be destroyed.
- if (objectId == 0) {
- return false;
- }
-
+ WireResult Server::DoDestroyObject(ObjectType objectType, ObjectId objectId) {
switch(objectType) {
{% for type in by_category["object"] %}
case ObjectType::{{type.name.CamelCase()}}: {
Known<WGPU{{type.name.CamelCase()}}> obj;
- if (!{{type.name.CamelCase()}}Objects().Get(objectId, &obj)) {
- return false;
- }
+ WIRE_TRY({{type.name.CamelCase()}}Objects().Get(objectId, &obj));
+
if (obj->state == AllocationState::Allocated) {
ASSERT(obj->handle != nullptr);
{% if type.name.CamelCase() in server_reverse_lookup_objects %}
@@ -94,11 +88,11 @@
mProcs.{{as_varName(type.name, Name("release"))}}(obj->handle);
}
{{type.name.CamelCase()}}Objects().Free(objectId);
- return true;
+ return WireResult::Success;
}
{% endfor %}
default:
- return false;
+ return WireResult::FatalError;
}
}
diff --git a/generator/templates/dawn/wire/server/ServerHandlers.cpp b/generator/templates/dawn/wire/server/ServerHandlers.cpp
index 91cac0b..0f59d4c 100644
--- a/generator/templates/dawn/wire/server/ServerHandlers.cpp
+++ b/generator/templates/dawn/wire/server/ServerHandlers.cpp
@@ -23,22 +23,16 @@
{% set Suffix = command.name.CamelCase() %}
//* The generic command handlers
- bool Server::Handle{{Suffix}}(DeserializeBuffer* deserializeBuffer) {
+ WireResult Server::Handle{{Suffix}}(DeserializeBuffer* deserializeBuffer) {
{{Suffix}}Cmd cmd;
- WireResult deserializeResult = cmd.Deserialize(deserializeBuffer, &mAllocator
+ WIRE_TRY(cmd.Deserialize(deserializeBuffer, &mAllocator
{%- if command.may_have_dawn_object -%}
, *this
{%- endif -%}
- );
-
- if (deserializeResult == WireResult::FatalError) {
- return false;
- }
+ ));
{% if Suffix in server_custom_pre_handler_commands %}
- if (!PreHandle{{Suffix}}(cmd)) {
- return false;
- }
+ WIRE_TRY(PreHandle{{Suffix}}(cmd));
{% endif %}
//* Allocate any result objects
@@ -48,22 +42,18 @@
{% set name = as_varName(member.name) %}
Known<WGPU{{Type}}> {{name}}Data;
- if (!{{Type}}Objects().Allocate(&{{name}}Data, cmd.{{name}})) {
- return false;
- }
+ WIRE_TRY({{Type}}Objects().Allocate(&{{name}}Data, cmd.{{name}}));
{{name}}Data->generation = cmd.{{name}}.generation;
{% endfor %}
{%- for member in command.members if member.id_type != None -%}
{% set name = as_varName(member.name) %}
Known<WGPU{{member.id_type.name.CamelCase()}}> {{name}}Handle;
- if (!{{member.id_type.name.CamelCase()}}Objects().Get(cmd.{{name}}, &{{name}}Handle)) {
- return false;
- }
+ WIRE_TRY({{member.id_type.name.CamelCase()}}Objects().Get(cmd.{{name}}, &{{name}}Handle));
{%- endfor -%}
//* Do command
- bool success = Do{{Suffix}}(
+ WIRE_TRY(Do{{Suffix}}(
{%- for member in command.members -%}
{%- if member.is_return_value -%}
{%- if member.handle_type -%}
@@ -78,11 +68,7 @@
{%- endif -%}
{%- if not loop.last -%}, {% endif %}
{%- endfor -%}
- );
-
- if (!success) {
- return false;
- }
+ ));
{%- for member in command.members if member.is_return_value and member.handle_type -%}
{% set Type = member.handle_type.name.CamelCase() %}
@@ -94,7 +80,7 @@
{% endif %}
{% endfor %}
- return true;
+ return WireResult::Success;
}
{% endfor %}
@@ -115,18 +101,18 @@
WireCmd cmdId = *static_cast<const volatile WireCmd*>(static_cast<const volatile void*>(
deserializeBuffer.Buffer() + sizeof(CmdHeader)));
- bool success = false;
+ WireResult result;
switch (cmdId) {
{% for command in cmd_records["command"] %}
case WireCmd::{{command.name.CamelCase()}}:
- success = Handle{{command.name.CamelCase()}}(&deserializeBuffer);
+ result = Handle{{command.name.CamelCase()}}(&deserializeBuffer);
break;
{% endfor %}
default:
- success = false;
+ result = WireResult::FatalError;
}
- if (!success) {
+ if (result != WireResult::Success) {
return nullptr;
}
mAllocator.Reset();
diff --git a/generator/templates/dawn/wire/server/ServerPrototypes.inc b/generator/templates/dawn/wire/server/ServerPrototypes.inc
index 302343b..bab9ce9 100644
--- a/generator/templates/dawn/wire/server/ServerPrototypes.inc
+++ b/generator/templates/dawn/wire/server/ServerPrototypes.inc
@@ -15,9 +15,9 @@
// Command handlers & doers
{% for command in cmd_records["command"] %}
{% set Suffix = command.name.CamelCase() %}
- bool Handle{{Suffix}}(DeserializeBuffer* deserializeBuffer);
+ WireResult Handle{{Suffix}}(DeserializeBuffer* deserializeBuffer);
- bool Do{{Suffix}}(
+ WireResult Do{{Suffix}}(
{%- for member in command.members -%}
{%- if member.is_return_value -%}
{%- if member.handle_type -%}
@@ -36,5 +36,5 @@
{% endfor %}
{% for CommandName in server_custom_pre_handler_commands %}
- bool PreHandle{{CommandName}}(const {{CommandName}}Cmd& cmd);
+ WireResult PreHandle{{CommandName}}(const {{CommandName}}Cmd& cmd);
{% endfor %}
diff --git a/src/dawn/wire/WireServer.cpp b/src/dawn/wire/WireServer.cpp
index b864112..0be6e1e 100644
--- a/src/dawn/wire/WireServer.cpp
+++ b/src/dawn/wire/WireServer.cpp
@@ -35,7 +35,8 @@
uint32_t generation,
uint32_t deviceId,
uint32_t deviceGeneration) {
- return mImpl->InjectTexture(texture, id, generation, deviceId, deviceGeneration);
+ return mImpl->InjectTexture(texture, id, generation, deviceId, deviceGeneration) ==
+ WireResult::Success;
}
bool WireServer::InjectSwapChain(WGPUSwapChain swapchain,
@@ -43,15 +44,16 @@
uint32_t generation,
uint32_t deviceId,
uint32_t deviceGeneration) {
- return mImpl->InjectSwapChain(swapchain, id, generation, deviceId, deviceGeneration);
+ return mImpl->InjectSwapChain(swapchain, id, generation, deviceId, deviceGeneration) ==
+ WireResult::Success;
}
bool WireServer::InjectDevice(WGPUDevice device, uint32_t id, uint32_t generation) {
- return mImpl->InjectDevice(device, id, generation);
+ return mImpl->InjectDevice(device, id, generation) == WireResult::Success;
}
bool WireServer::InjectInstance(WGPUInstance instance, uint32_t id, uint32_t generation) {
- return mImpl->InjectInstance(instance, id, generation);
+ return mImpl->InjectInstance(instance, id, generation) == WireResult::Success;
}
WGPUDevice WireServer::GetDevice(uint32_t id, uint32_t generation) {
diff --git a/src/dawn/wire/server/ObjectStorage.h b/src/dawn/wire/server/ObjectStorage.h
index 6d3167c..daac448 100644
--- a/src/dawn/wire/server/ObjectStorage.h
+++ b/src/dawn/wire/server/ObjectStorage.h
@@ -111,33 +111,33 @@
}
// Get a backend objects for a given client ID.
- // Returns whether the object was previously allocated.
- bool GetNativeHandle(ObjectId id, T* handle) const {
+ // Returns an error if the object wasn't previously allocated.
+ WireResult GetNativeHandle(ObjectId id, T* handle) const {
if (id >= mKnown.size()) {
- return false;
+ return WireResult::FatalError;
}
const Data* data = &mKnown[id];
if (data->state != AllocationState::Allocated) {
- return false;
+ return WireResult::FatalError;
}
*handle = data->handle;
- return true;
+ return WireResult::Success;
}
- bool Get(ObjectId id, Known<T>* result) {
+ WireResult Get(ObjectId id, Known<T>* result) {
if (id >= mKnown.size()) {
- return false;
+ return WireResult::FatalError;
}
Data* data = &mKnown[id];
if (data->state != AllocationState::Allocated) {
- return false;
+ return WireResult::FatalError;
}
*result = Known<T>{id, data};
- return true;
+ return WireResult::Success;
}
Known<T> FillReservation(ObjectId id, T handle) {
@@ -152,11 +152,11 @@
// Allocates the data for a given ID and returns it in result.
// Returns false if the ID is already allocated, or too far ahead, or if ID is 0 (ID 0 is
// reserved for nullptr). Invalidates all the Data*
- bool Allocate(Known<T>* result,
- ObjectHandle handle,
- AllocationState state = AllocationState::Allocated) {
+ WireResult Allocate(Known<T>* result,
+ ObjectHandle handle,
+ AllocationState state = AllocationState::Allocated) {
if (handle.id == 0 || handle.id > mKnown.size()) {
- return false;
+ return WireResult::FatalError;
}
Data data;
@@ -166,16 +166,16 @@
if (handle.id >= mKnown.size()) {
mKnown.push_back(std::move(data));
*result = {handle.id, &mKnown.back()};
- return true;
+ return WireResult::Success;
}
if (mKnown[handle.id].state != AllocationState::Free) {
- return false;
+ return WireResult::FatalError;
}
// The generation should be strictly increasing.
if (handle.generation <= mKnown[handle.id].generation) {
- return false;
+ return WireResult::FatalError;
}
// update the generation in the slot
data.generation = handle.generation;
@@ -183,7 +183,7 @@
mKnown[handle.id] = std::move(data);
*result = {handle.id, &mKnown[handle.id]};
- return true;
+ return WireResult::Success;
}
// Marks an ID as deallocated
@@ -231,14 +231,12 @@
public:
KnownObjects() = default;
- bool Allocate(Known<WGPUDevice>* result,
- ObjectHandle handle,
- AllocationState state = AllocationState::Allocated) {
- if (KnownObjectsBase<WGPUDevice>::Allocate(result, handle, state)) {
- AddToKnownSet(*result);
- return true;
- }
- return false;
+ WireResult Allocate(Known<WGPUDevice>* result,
+ ObjectHandle handle,
+ AllocationState state = AllocationState::Allocated) {
+ WIRE_TRY(KnownObjectsBase<WGPUDevice>::Allocate(result, handle, state));
+ AddToKnownSet(*result);
+ return WireResult::Success;
}
Known<WGPUDevice> FillReservation(ObjectId id, WGPUDevice handle) {
diff --git a/src/dawn/wire/server/Server.cpp b/src/dawn/wire/server/Server.cpp
index 8c9c62d..e51eb55 100644
--- a/src/dawn/wire/server/Server.cpp
+++ b/src/dawn/wire/server/Server.cpp
@@ -43,21 +43,20 @@
DestroyAllObjects(mProcs);
}
-bool Server::InjectTexture(WGPUTexture texture,
- uint32_t id,
- uint32_t generation,
- uint32_t deviceId,
- uint32_t deviceGeneration) {
+WireResult Server::InjectTexture(WGPUTexture texture,
+ uint32_t id,
+ uint32_t generation,
+ uint32_t deviceId,
+ uint32_t deviceGeneration) {
ASSERT(texture != nullptr);
Known<WGPUDevice> device;
- if (!DeviceObjects().Get(deviceId, &device) || device->generation != deviceGeneration) {
- return false;
+ WIRE_TRY(DeviceObjects().Get(deviceId, &device));
+ if (device->generation != deviceGeneration) {
+ return WireResult::FatalError;
}
Known<WGPUTexture> data;
- if (!TextureObjects().Allocate(&data, ObjectHandle{id, generation})) {
- return false;
- }
+ WIRE_TRY(TextureObjects().Allocate(&data, ObjectHandle{id, generation}));
data->handle = texture;
data->generation = generation;
@@ -67,24 +66,23 @@
// message from the client. Add a reference to counterbalance the eventual release.
mProcs.textureReference(texture);
- return true;
+ return WireResult::Success;
}
-bool Server::InjectSwapChain(WGPUSwapChain swapchain,
- uint32_t id,
- uint32_t generation,
- uint32_t deviceId,
- uint32_t deviceGeneration) {
+WireResult Server::InjectSwapChain(WGPUSwapChain swapchain,
+ uint32_t id,
+ uint32_t generation,
+ uint32_t deviceId,
+ uint32_t deviceGeneration) {
ASSERT(swapchain != nullptr);
Known<WGPUDevice> device;
- if (!DeviceObjects().Get(deviceId, &device) || device->generation != deviceGeneration) {
- return false;
+ WIRE_TRY(DeviceObjects().Get(deviceId, &device));
+ if (device->generation != deviceGeneration) {
+ return WireResult::FatalError;
}
Known<WGPUSwapChain> data;
- if (!SwapChainObjects().Allocate(&data, ObjectHandle{id, generation})) {
- return false;
- }
+ WIRE_TRY(SwapChainObjects().Allocate(&data, ObjectHandle{id, generation}));
data->handle = swapchain;
data->generation = generation;
@@ -94,15 +92,13 @@
// message from the client. Add a reference to counterbalance the eventual release.
mProcs.swapChainReference(swapchain);
- return true;
+ return WireResult::Success;
}
-bool Server::InjectDevice(WGPUDevice device, uint32_t id, uint32_t generation) {
+WireResult Server::InjectDevice(WGPUDevice device, uint32_t id, uint32_t generation) {
ASSERT(device != nullptr);
Known<WGPUDevice> data;
- if (!DeviceObjects().Allocate(&data, ObjectHandle{id, generation})) {
- return false;
- }
+ WIRE_TRY(DeviceObjects().Allocate(&data, ObjectHandle{id, generation}));
data->handle = device;
data->generation = generation;
@@ -116,15 +112,13 @@
// Set callbacks to forward errors to the client.
SetForwardingDeviceCallbacks(data);
- return true;
+ return WireResult::Success;
}
-bool Server::InjectInstance(WGPUInstance instance, uint32_t id, uint32_t generation) {
+WireResult Server::InjectInstance(WGPUInstance instance, uint32_t id, uint32_t generation) {
ASSERT(instance != nullptr);
Known<WGPUInstance> data;
- if (!InstanceObjects().Allocate(&data, ObjectHandle{id, generation})) {
- return false;
- }
+ WIRE_TRY(InstanceObjects().Allocate(&data, ObjectHandle{id, generation}));
data->handle = instance;
data->generation = generation;
@@ -134,12 +128,13 @@
// message from the client. Add a reference to counterbalance the eventual release.
mProcs.instanceReference(instance);
- return true;
+ return WireResult::Success;
}
WGPUDevice Server::GetDevice(uint32_t id, uint32_t generation) {
Known<WGPUDevice> device;
- if (!DeviceObjects().Get(id, &device) || device->generation != generation) {
+ if (DeviceObjects().Get(id, &device) != WireResult::Success ||
+ device->generation != generation) {
return nullptr;
}
return device->handle;
diff --git a/src/dawn/wire/server/Server.h b/src/dawn/wire/server/Server.h
index fbf8f14..61058ba 100644
--- a/src/dawn/wire/server/Server.h
+++ b/src/dawn/wire/server/Server.h
@@ -153,21 +153,21 @@
// ChunkedCommandHandler implementation
const volatile char* HandleCommandsImpl(const volatile char* commands, size_t size) override;
- bool InjectTexture(WGPUTexture texture,
- uint32_t id,
- uint32_t generation,
- uint32_t deviceId,
- uint32_t deviceGeneration);
+ WireResult InjectTexture(WGPUTexture texture,
+ uint32_t id,
+ uint32_t generation,
+ uint32_t deviceId,
+ uint32_t deviceGeneration);
- bool InjectSwapChain(WGPUSwapChain swapchain,
- uint32_t id,
- uint32_t generation,
- uint32_t deviceId,
- uint32_t deviceGeneration);
+ WireResult InjectSwapChain(WGPUSwapChain swapchain,
+ uint32_t id,
+ uint32_t generation,
+ uint32_t deviceId,
+ uint32_t deviceGeneration);
- bool InjectDevice(WGPUDevice device, uint32_t id, uint32_t generation);
+ WireResult InjectDevice(WGPUDevice device, uint32_t id, uint32_t generation);
- bool InjectInstance(WGPUInstance instance, uint32_t id, uint32_t generation);
+ WireResult InjectInstance(WGPUInstance instance, uint32_t id, uint32_t generation);
WGPUDevice GetDevice(uint32_t id, uint32_t generation);
bool IsDeviceKnown(WGPUDevice device) const;
diff --git a/src/dawn/wire/server/ServerAdapter.cpp b/src/dawn/wire/server/ServerAdapter.cpp
index 67dc056..2c19136 100644
--- a/src/dawn/wire/server/ServerAdapter.cpp
+++ b/src/dawn/wire/server/ServerAdapter.cpp
@@ -19,14 +19,12 @@
namespace dawn::wire::server {
-bool Server::DoAdapterRequestDevice(Known<WGPUAdapter> adapter,
- uint64_t requestSerial,
- ObjectHandle deviceHandle,
- const WGPUDeviceDescriptor* descriptor) {
+WireResult Server::DoAdapterRequestDevice(Known<WGPUAdapter> adapter,
+ uint64_t requestSerial,
+ ObjectHandle deviceHandle,
+ const WGPUDeviceDescriptor* descriptor) {
Known<WGPUDevice> device;
- if (!DeviceObjects().Allocate(&device, deviceHandle, AllocationState::Reserved)) {
- return false;
- }
+ WIRE_TRY(DeviceObjects().Allocate(&device, deviceHandle, AllocationState::Reserved));
auto userdata = MakeUserdata<RequestDeviceUserdata>();
userdata->adapter = adapter.AsHandle();
@@ -36,7 +34,7 @@
mProcs.adapterRequestDevice(adapter->handle, descriptor,
ForwardToServer<&Server::OnRequestDeviceCallback>,
userdata.release());
- return true;
+ return WireResult::Success;
}
void Server::OnRequestDeviceCallback(RequestDeviceUserdata* data,
diff --git a/src/dawn/wire/server/ServerBuffer.cpp b/src/dawn/wire/server/ServerBuffer.cpp
index c4c89ba..9040f7a 100644
--- a/src/dawn/wire/server/ServerBuffer.cpp
+++ b/src/dawn/wire/server/ServerBuffer.cpp
@@ -22,11 +22,9 @@
namespace dawn::wire::server {
-bool Server::PreHandleBufferUnmap(const BufferUnmapCmd& cmd) {
+WireResult Server::PreHandleBufferUnmap(const BufferUnmapCmd& cmd) {
Known<WGPUBuffer> buffer;
- if (!BufferObjects().Get(cmd.selfId, &buffer)) {
- return false;
- }
+ WIRE_TRY(BufferObjects().Get(cmd.selfId, &buffer));
if (buffer->mappedAtCreation && !(buffer->usage & WGPUMapMode_Write)) {
// This indicates the writeHandle is for mappedAtCreation only. Destroy on unmap
@@ -37,29 +35,27 @@
buffer->mapWriteState = BufferMapWriteState::Unmapped;
- return true;
+ return WireResult::Success;
}
-bool Server::PreHandleBufferDestroy(const BufferDestroyCmd& cmd) {
+WireResult Server::PreHandleBufferDestroy(const BufferDestroyCmd& cmd) {
// Destroying a buffer does an implicit unmapping.
Known<WGPUBuffer> buffer;
- if (!BufferObjects().Get(cmd.selfId, &buffer)) {
- return false;
- }
+ WIRE_TRY(BufferObjects().Get(cmd.selfId, &buffer));
// The buffer was destroyed. Clear the Read/WriteHandle.
buffer->readHandle = nullptr;
buffer->writeHandle = nullptr;
buffer->mapWriteState = BufferMapWriteState::Unmapped;
- return true;
+ return WireResult::Success;
}
-bool Server::DoBufferMapAsync(Known<WGPUBuffer> buffer,
- uint64_t requestSerial,
- WGPUMapModeFlags mode,
- uint64_t offset64,
- uint64_t size64) {
+WireResult Server::DoBufferMapAsync(Known<WGPUBuffer> buffer,
+ uint64_t requestSerial,
+ WGPUMapModeFlags mode,
+ uint64_t offset64,
+ uint64_t size64) {
// 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>();
@@ -75,11 +71,11 @@
// in server. All other invalid actual size can be caught by dawn native side validation.
if (offset64 > std::numeric_limits<size_t>::max()) {
OnBufferMapAsyncCallback(userdata.get(), WGPUBufferMapAsyncStatus_OffsetOutOfRange);
- return true;
+ return WireResult::Success;
}
if (size64 >= WGPU_WHOLE_MAP_SIZE) {
OnBufferMapAsyncCallback(userdata.get(), WGPUBufferMapAsyncStatus_SizeOutOfRange);
- return true;
+ return WireResult::Success;
}
size_t offset = static_cast<size_t>(offset64);
@@ -91,21 +87,19 @@
mProcs.bufferMapAsync(buffer->handle, mode, offset, size,
ForwardToServer<&Server::OnBufferMapAsyncCallback>, userdata.release());
- return true;
+ return WireResult::Success;
}
-bool Server::DoDeviceCreateBuffer(Known<WGPUDevice> device,
- const WGPUBufferDescriptor* descriptor,
- ObjectHandle bufferHandle,
- uint64_t readHandleCreateInfoLength,
- const uint8_t* readHandleCreateInfo,
- uint64_t writeHandleCreateInfoLength,
- const uint8_t* writeHandleCreateInfo) {
+WireResult Server::DoDeviceCreateBuffer(Known<WGPUDevice> device,
+ const WGPUBufferDescriptor* descriptor,
+ ObjectHandle bufferHandle,
+ uint64_t readHandleCreateInfoLength,
+ const uint8_t* readHandleCreateInfo,
+ uint64_t writeHandleCreateInfoLength,
+ const uint8_t* writeHandleCreateInfo) {
// Create and register the buffer object.
Known<WGPUBuffer> buffer;
- if (!BufferObjects().Allocate(&buffer, bufferHandle)) {
- return false;
- }
+ WIRE_TRY(BufferObjects().Allocate(&buffer, bufferHandle));
buffer->handle = mProcs.deviceCreateBuffer(device->handle, descriptor);
buffer->usage = descriptor->usage;
buffer->mappedAtCreation = descriptor->mappedAtCreation;
@@ -121,7 +115,7 @@
writeHandleCreateInfoLength > std::numeric_limits<size_t>::max() ||
readHandleCreateInfoLength >
std::numeric_limits<size_t>::max() - writeHandleCreateInfoLength) {
- return false;
+ return WireResult::FatalError;
}
if (isWriteMode) {
@@ -130,7 +124,7 @@
if (!mMemoryTransferService->DeserializeWriteHandle(
writeHandleCreateInfo, static_cast<size_t>(writeHandleCreateInfoLength),
&writeHandle)) {
- return false;
+ return WireResult::FatalError;
}
ASSERT(writeHandle != nullptr);
buffer->writeHandle.reset(writeHandle);
@@ -143,7 +137,7 @@
// This is a valid case and isn't fatal. Remember the buffer is an error so as
// to skip subsequent mapping operations.
buffer->mapWriteState = BufferMapWriteState::MapError;
- return true;
+ return WireResult::Success;
}
ASSERT(mapping != nullptr);
writeHandle->SetTarget(mapping);
@@ -158,53 +152,56 @@
if (!mMemoryTransferService->DeserializeReadHandle(
readHandleCreateInfo, static_cast<size_t>(readHandleCreateInfoLength),
&readHandle)) {
- return false;
+ return WireResult::FatalError;
}
ASSERT(readHandle != nullptr);
buffer->readHandle.reset(readHandle);
}
- return true;
+ return WireResult::Success;
}
-bool Server::DoBufferUpdateMappedData(Known<WGPUBuffer> buffer,
- uint64_t writeDataUpdateInfoLength,
- const uint8_t* writeDataUpdateInfo,
- uint64_t offset,
- uint64_t size) {
+WireResult Server::DoBufferUpdateMappedData(Known<WGPUBuffer> buffer,
+ uint64_t writeDataUpdateInfoLength,
+ const uint8_t* writeDataUpdateInfo,
+ uint64_t offset,
+ uint64_t size) {
if (writeDataUpdateInfoLength > std::numeric_limits<size_t>::max() ||
offset > std::numeric_limits<size_t>::max() || size > std::numeric_limits<size_t>::max()) {
- return false;
+ return WireResult::FatalError;
}
switch (buffer->mapWriteState) {
case BufferMapWriteState::Unmapped:
- return false;
+ return WireResult::FatalError;
case BufferMapWriteState::MapError:
// The buffer is mapped but there was an error allocating mapped data.
// Do not perform the memcpy.
- return true;
+ return WireResult::Success;
case BufferMapWriteState::Mapped:
break;
}
if (!buffer->writeHandle) {
// This check is performed after the check for the MapError state. It is permissible
// to Unmap and attempt to update mapped data of an error buffer.
- return false;
+ return WireResult::FatalError;
}
// Deserialize the flush info and flush updated data from the handle into the target
// of the handle. The target is set via WriteHandle::SetTarget.
- return buffer->writeHandle->DeserializeDataUpdate(
- writeDataUpdateInfo, static_cast<size_t>(writeDataUpdateInfoLength),
- static_cast<size_t>(offset), static_cast<size_t>(size));
+ if (!buffer->writeHandle->DeserializeDataUpdate(
+ writeDataUpdateInfo, static_cast<size_t>(writeDataUpdateInfoLength),
+ static_cast<size_t>(offset), static_cast<size_t>(size))) {
+ return WireResult::FatalError;
+ }
+ return WireResult::Success;
}
void Server::OnBufferMapAsyncCallback(MapUserdata* data, WGPUBufferMapAsyncStatus status) {
// Skip sending the callback if the buffer has already been destroyed.
Known<WGPUBuffer> buffer;
- if (!BufferObjects().Get(data->buffer.id, &buffer) ||
+ if (BufferObjects().Get(data->buffer.id, &buffer) != WireResult::Success ||
buffer->generation != data->buffer.generation) {
return;
}
diff --git a/src/dawn/wire/server/ServerDevice.cpp b/src/dawn/wire/server/ServerDevice.cpp
index 4ca0597..0c1dd09 100644
--- a/src/dawn/wire/server/ServerDevice.cpp
+++ b/src/dawn/wire/server/ServerDevice.cpp
@@ -61,14 +61,14 @@
SerializeCommand(cmd);
}
-bool Server::DoDevicePopErrorScope(Known<WGPUDevice> device, uint64_t requestSerial) {
+WireResult Server::DoDevicePopErrorScope(Known<WGPUDevice> device, uint64_t requestSerial) {
auto userdata = MakeUserdata<ErrorScopeUserdata>();
userdata->requestSerial = requestSerial;
userdata->device = device.AsHandle();
mProcs.devicePopErrorScope(device->handle, ForwardToServer<&Server::OnDevicePopErrorScope>,
userdata.release());
- return true;
+ return WireResult::Success;
}
void Server::OnDevicePopErrorScope(ErrorScopeUserdata* userdata,
@@ -83,15 +83,14 @@
SerializeCommand(cmd);
}
-bool Server::DoDeviceCreateComputePipelineAsync(Known<WGPUDevice> device,
- uint64_t requestSerial,
- ObjectHandle pipelineObjectHandle,
- const WGPUComputePipelineDescriptor* descriptor) {
+WireResult Server::DoDeviceCreateComputePipelineAsync(
+ Known<WGPUDevice> device,
+ uint64_t requestSerial,
+ ObjectHandle pipelineObjectHandle,
+ const WGPUComputePipelineDescriptor* descriptor) {
Known<WGPUComputePipeline> pipeline;
- if (!ComputePipelineObjects().Allocate(&pipeline, pipelineObjectHandle,
- AllocationState::Reserved)) {
- return false;
- }
+ WIRE_TRY(ComputePipelineObjects().Allocate(&pipeline, pipelineObjectHandle,
+ AllocationState::Reserved));
auto userdata = MakeUserdata<CreatePipelineAsyncUserData>();
userdata->device = device.AsHandle();
@@ -101,7 +100,7 @@
mProcs.deviceCreateComputePipelineAsync(
device->handle, descriptor, ForwardToServer<&Server::OnCreateComputePipelineAsyncCallback>,
userdata.release());
- return true;
+ return WireResult::Success;
}
void Server::OnCreateComputePipelineAsyncCallback(CreatePipelineAsyncUserData* data,
@@ -120,15 +119,14 @@
SerializeCommand(cmd);
}
-bool Server::DoDeviceCreateRenderPipelineAsync(Known<WGPUDevice> device,
- uint64_t requestSerial,
- ObjectHandle pipelineObjectHandle,
- const WGPURenderPipelineDescriptor* descriptor) {
+WireResult Server::DoDeviceCreateRenderPipelineAsync(
+ Known<WGPUDevice> device,
+ uint64_t requestSerial,
+ ObjectHandle pipelineObjectHandle,
+ const WGPURenderPipelineDescriptor* descriptor) {
Known<WGPURenderPipeline> pipeline;
- if (!RenderPipelineObjects().Allocate(&pipeline, pipelineObjectHandle,
- AllocationState::Reserved)) {
- return false;
- }
+ WIRE_TRY(RenderPipelineObjects().Allocate(&pipeline, pipelineObjectHandle,
+ AllocationState::Reserved));
auto userdata = MakeUserdata<CreatePipelineAsyncUserData>();
userdata->device = device.AsHandle();
@@ -138,7 +136,7 @@
mProcs.deviceCreateRenderPipelineAsync(
device->handle, descriptor, ForwardToServer<&Server::OnCreateRenderPipelineAsyncCallback>,
userdata.release());
- return true;
+ return WireResult::Success;
}
void Server::OnCreateRenderPipelineAsyncCallback(CreatePipelineAsyncUserData* data,
diff --git a/src/dawn/wire/server/ServerInstance.cpp b/src/dawn/wire/server/ServerInstance.cpp
index 4074b8c..c4982fb 100644
--- a/src/dawn/wire/server/ServerInstance.cpp
+++ b/src/dawn/wire/server/ServerInstance.cpp
@@ -20,14 +20,12 @@
namespace dawn::wire::server {
-bool Server::DoInstanceRequestAdapter(Known<WGPUInstance> instance,
- uint64_t requestSerial,
- ObjectHandle adapterHandle,
- const WGPURequestAdapterOptions* options) {
+WireResult Server::DoInstanceRequestAdapter(Known<WGPUInstance> instance,
+ uint64_t requestSerial,
+ ObjectHandle adapterHandle,
+ const WGPURequestAdapterOptions* options) {
Known<WGPUAdapter> adapter;
- if (!AdapterObjects().Allocate(&adapter, adapterHandle, AllocationState::Reserved)) {
- return false;
- }
+ WIRE_TRY(AdapterObjects().Allocate(&adapter, adapterHandle, AllocationState::Reserved));
auto userdata = MakeUserdata<RequestAdapterUserdata>();
userdata->instance = instance.AsHandle();
@@ -37,7 +35,7 @@
mProcs.instanceRequestAdapter(instance->handle, options,
ForwardToServer<&Server::OnRequestAdapterCallback>,
userdata.release());
- return true;
+ return WireResult::Success;
}
void Server::OnRequestAdapterCallback(RequestAdapterUserdata* data,
diff --git a/src/dawn/wire/server/ServerQueue.cpp b/src/dawn/wire/server/ServerQueue.cpp
index b464133..d18ffc7 100644
--- a/src/dawn/wire/server/ServerQueue.cpp
+++ b/src/dawn/wire/server/ServerQueue.cpp
@@ -28,45 +28,45 @@
SerializeCommand(cmd);
}
-bool Server::DoQueueOnSubmittedWorkDone(Known<WGPUQueue> queue,
- uint64_t signalValue,
- uint64_t requestSerial) {
+WireResult Server::DoQueueOnSubmittedWorkDone(Known<WGPUQueue> queue,
+ uint64_t signalValue,
+ uint64_t requestSerial) {
auto userdata = MakeUserdata<QueueWorkDoneUserdata>();
userdata->queue = queue.AsHandle();
userdata->requestSerial = requestSerial;
mProcs.queueOnSubmittedWorkDone(queue->handle, signalValue,
ForwardToServer<&Server::OnQueueWorkDone>, userdata.release());
- return true;
+ return WireResult::Success;
}
-bool Server::DoQueueWriteBuffer(Known<WGPUQueue> queue,
- Known<WGPUBuffer> buffer,
- uint64_t bufferOffset,
- const uint8_t* data,
- uint64_t size) {
+WireResult Server::DoQueueWriteBuffer(Known<WGPUQueue> queue,
+ Known<WGPUBuffer> buffer,
+ uint64_t bufferOffset,
+ const uint8_t* data,
+ uint64_t size) {
if (size > std::numeric_limits<size_t>::max()) {
- return false;
+ return WireResult::FatalError;
}
mProcs.queueWriteBuffer(queue->handle, buffer->handle, bufferOffset, data,
static_cast<size_t>(size));
- return true;
+ return WireResult::Success;
}
-bool Server::DoQueueWriteTexture(Known<WGPUQueue> queue,
- const WGPUImageCopyTexture* destination,
- const uint8_t* data,
- uint64_t dataSize,
- const WGPUTextureDataLayout* dataLayout,
- const WGPUExtent3D* writeSize) {
+WireResult Server::DoQueueWriteTexture(Known<WGPUQueue> queue,
+ const WGPUImageCopyTexture* destination,
+ const uint8_t* data,
+ uint64_t dataSize,
+ const WGPUTextureDataLayout* dataLayout,
+ const WGPUExtent3D* writeSize) {
if (dataSize > std::numeric_limits<size_t>::max()) {
- return false;
+ return WireResult::FatalError;
}
mProcs.queueWriteTexture(queue->handle, destination, data, static_cast<size_t>(dataSize),
dataLayout, writeSize);
- return true;
+ return WireResult::Success;
}
} // namespace dawn::wire::server
diff --git a/src/dawn/wire/server/ServerShaderModule.cpp b/src/dawn/wire/server/ServerShaderModule.cpp
index 78a198c..8328501 100644
--- a/src/dawn/wire/server/ServerShaderModule.cpp
+++ b/src/dawn/wire/server/ServerShaderModule.cpp
@@ -18,8 +18,8 @@
namespace dawn::wire::server {
-bool Server::DoShaderModuleGetCompilationInfo(Known<WGPUShaderModule> shaderModule,
- uint64_t requestSerial) {
+WireResult Server::DoShaderModuleGetCompilationInfo(Known<WGPUShaderModule> shaderModule,
+ uint64_t requestSerial) {
auto userdata = MakeUserdata<ShaderModuleGetCompilationInfoUserdata>();
userdata->shaderModule = shaderModule.AsHandle();
userdata->requestSerial = requestSerial;
@@ -27,7 +27,7 @@
mProcs.shaderModuleGetCompilationInfo(
shaderModule->handle, ForwardToServer<&Server::OnShaderModuleGetCompilationInfo>,
userdata.release());
- return true;
+ return WireResult::Success;
}
void Server::OnShaderModuleGetCompilationInfo(ShaderModuleGetCompilationInfoUserdata* data,
