Factor wire client handlers into proper command handlers and doers
Bug: dawn:88
Change-Id: I3ab28efad7edc7d06f11aa5abae07a1bb3d7e59e
Reviewed-on: https://dawn-review.googlesource.com/c/4003
Commit-Queue: Austin Eng <enga@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
diff --git a/BUILD.gn b/BUILD.gn
index e3ebd1d..9475c87 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -764,6 +764,7 @@
"dawn_wire/client/ApiProcs_autogen.cpp",
"dawn_wire/client/ApiProcs_autogen.h",
"dawn_wire/client/ClientBase_autogen.h",
+ "dawn_wire/client/ClientDoers_autogen.cpp",
"dawn_wire/client/ClientHandlers_autogen.cpp",
"dawn_wire/client/ClientPrototypes_autogen.inl",
"dawn_wire/server/ServerBase_autogen.h",
@@ -794,7 +795,7 @@
"src/dawn_wire/client/Buffer.h",
"src/dawn_wire/client/Client.cpp",
"src/dawn_wire/client/Client.h",
- "src/dawn_wire/client/ClientHandlers.cpp",
+ "src/dawn_wire/client/ClientDoers.cpp",
"src/dawn_wire/client/Device.cpp",
"src/dawn_wire/client/Device.h",
"src/dawn_wire/client/Fence.cpp",
diff --git a/dawn_wire.json b/dawn_wire.json
index eaa93b2..cb55415 100644
--- a/dawn_wire.json
+++ b/dawn_wire.json
@@ -34,14 +34,14 @@
},
"return commands": {
"buffer map read async callback": [
- { "name": "buffer", "type": "ObjectHandle" },
+ { "name": "buffer", "type": "ObjectHandle", "handle_type": "buffer" },
{ "name": "request serial", "type": "uint32_t" },
{ "name": "status", "type": "uint32_t" },
{ "name": "data length", "type": "uint32_t" },
{ "name": "data", "type": "uint8_t", "annotation": "const*", "length": "data length" }
],
"buffer map write async callback": [
- { "name": "buffer", "type": "ObjectHandle" },
+ { "name": "buffer", "type": "ObjectHandle", "handle_type": "buffer" },
{ "name": "request serial", "type": "uint32_t" },
{ "name": "status", "type": "uint32_t" }
],
@@ -49,7 +49,7 @@
{ "name": "message", "type": "char", "annotation": "const*", "length": "strlen" }
],
"fence update completed value": [
- { "name": "fence", "type": "ObjectHandle" },
+ { "name": "fence", "type": "ObjectHandle", "handle_type": "fence" },
{ "name": "value", "type": "uint64_t" }
]
},
@@ -57,9 +57,10 @@
"client_side_commands": [
"FenceGetCompletedValue"
],
- "client_proxied_commands": [
+ "client_handwritten_commands": [
"BufferUnmap",
"DeviceCreateFence",
+ "FenceGetCompletedValue",
"QueueSignal"
],
"client_special_objects": [
diff --git a/generator/common.py b/generator/common.py
index 977dee9..aa5211d 100644
--- a/generator/common.py
+++ b/generator/common.py
@@ -84,6 +84,11 @@
self.length = None
self.optional = optional
self.is_return_value = is_return_value
+ self.handle_type = None
+
+ def set_handle_type(self, handle_type):
+ assert self.type.dict_name == "ObjectHandle"
+ self.handle_type = handle_type
Method = namedtuple('Method', ['name', 'return_type', 'arguments'])
class ObjectType(Type):
@@ -130,6 +135,9 @@
member = RecordMember(Name(m['name']), types[m['type']],
m.get('annotation', 'value'), m.get('optional', False),
m.get('is_return_value', False))
+ handle_type = m.get('handle_type')
+ if handle_type:
+ member.set_handle_type(types[handle_type])
members.append(member)
members_by_name[member.name.canonical_case()] = member
diff --git a/generator/main.py b/generator/main.py
index bbc0869..d695353 100644
--- a/generator/main.py
+++ b/generator/main.py
@@ -388,6 +388,7 @@
renders.append(FileRender('dawn_wire/client/ApiProcs.cpp', 'dawn_wire/client/ApiProcs_autogen.cpp', wire_params))
renders.append(FileRender('dawn_wire/client/ApiProcs.h', 'dawn_wire/client/ApiProcs_autogen.h', wire_params))
renders.append(FileRender('dawn_wire/client/ClientBase.h', 'dawn_wire/client/ClientBase_autogen.h', wire_params))
+ renders.append(FileRender('dawn_wire/client/ClientDoers.cpp', 'dawn_wire/client/ClientDoers_autogen.cpp', wire_params))
renders.append(FileRender('dawn_wire/client/ClientHandlers.cpp', 'dawn_wire/client/ClientHandlers_autogen.cpp', wire_params))
renders.append(FileRender('dawn_wire/client/ClientPrototypes.inl', 'dawn_wire/client/ClientPrototypes_autogen.inl', wire_params))
renders.append(FileRender('dawn_wire/server/ServerBase.h', 'dawn_wire/server/ServerBase_autogen.h', wire_params))
diff --git a/generator/templates/dawn_wire/client/ApiProcs.cpp b/generator/templates/dawn_wire/client/ApiProcs.cpp
index a5c6282..933d937 100644
--- a/generator/templates/dawn_wire/client/ApiProcs.cpp
+++ b/generator/templates/dawn_wire/client/ApiProcs.cpp
@@ -24,7 +24,7 @@
{% for method in type.methods %}
{% set Suffix = as_MethodSuffix(type.name, method.name) %}
- {% if Suffix not in client_side_commands %}
+ {% if Suffix not in client_handwritten_commands %}
{{as_cType(method.return_type.name)}} Client{{Suffix}}(
{{-cType}} cSelf
{%- for arg in method.arguments -%}
@@ -122,11 +122,7 @@
{% for type in by_category["object"] %}
{% for method in native_methods(type) %}
{% set suffix = as_MethodSuffix(type.name, method.name) %}
- {% if suffix in client_proxied_commands %}
- table.{{as_varName(type.name, method.name)}} = ProxyClient{{suffix}};
- {% else %}
- table.{{as_varName(type.name, method.name)}} = Client{{suffix}};
- {% endif %}
+ table.{{as_varName(type.name, method.name)}} = Client{{suffix}};
{% endfor %}
{% endfor %}
return table;
diff --git a/generator/templates/dawn_wire/client/ApiProcs.h b/generator/templates/dawn_wire/client/ApiProcs.h
index 91489f2..3eedc34 100644
--- a/generator/templates/dawn_wire/client/ApiProcs.h
+++ b/generator/templates/dawn_wire/client/ApiProcs.h
@@ -24,14 +24,6 @@
{% set cType = as_cType(type.name) %}
{% for method in native_methods(type) %}
{% set Suffix = as_MethodSuffix(type.name, method.name) %}
- {% if Suffix in client_proxied_commands %}
- {{as_cType(method.return_type.name)}} ProxyClient{{Suffix}}(
- {{-cType}} cSelf
- {%- for arg in method.arguments -%}
- , {{as_annotated_cType(arg)}}
- {%- endfor -%}
- );
- {% endif %}
{{as_cType(method.return_type.name)}} Client{{Suffix}}(
{{-cType}} cSelf
{%- for arg in method.arguments -%}
diff --git a/generator/templates/dawn_wire/client/ClientDoers.cpp b/generator/templates/dawn_wire/client/ClientDoers.cpp
new file mode 100644
index 0000000..6226498
--- /dev/null
+++ b/generator/templates/dawn_wire/client/ClientDoers.cpp
@@ -0,0 +1,39 @@
+//* 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/client/Client.h"
+
+#include <string>
+
+namespace dawn_wire {
+ namespace client {
+ {% for type in by_category["object"] if type.is_builder %}
+ {% set Type = type.name.CamelCase() %}
+ bool Client::Do{{Type}}ErrorCallback({{type.built_type.name.CamelCase()}}* object, uint32_t status, const char* message) {
+ //* The object might have been deleted or a new object created with the same ID.
+ if (object == nullptr) {
+ return true;
+ }
+ bool called = object->builderCallback.Call(static_cast<dawnBuilderErrorStatus>(status), message);
+
+ //* Unhandled builder errors are forwarded to the device
+ if (!called && status != DAWN_BUILDER_ERROR_STATUS_SUCCESS && status != DAWN_BUILDER_ERROR_STATUS_UNKNOWN) {
+ mDevice->HandleError(("Unhandled builder error: " + std::string(message)).c_str());
+ }
+
+ return true;
+ }
+ {% endfor %}
+ }
+}
diff --git a/generator/templates/dawn_wire/client/ClientHandlers.cpp b/generator/templates/dawn_wire/client/ClientHandlers.cpp
index 75beddc..60eb9ee 100644
--- a/generator/templates/dawn_wire/client/ClientHandlers.cpp
+++ b/generator/templates/dawn_wire/client/ClientHandlers.cpp
@@ -18,34 +18,38 @@
#include <string>
namespace dawn_wire { namespace client {
- {% for type in by_category["object"] if type.is_builder %}
- {% set Type = type.name.CamelCase() %}
- bool Client::Handle{{Type}}ErrorCallback(const char** commands, size_t* size) {
- Return{{Type}}ErrorCallbackCmd cmd;
+ {% for command in cmd_records["return command"] %}
+ bool Client::Handle{{command.name.CamelCase()}}(const char** commands, size_t* size) {
+ Return{{command.name.CamelCase()}}Cmd cmd;
DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
if (deserializeResult == DeserializeResult::FatalError) {
return false;
}
- DAWN_ASSERT(cmd.message != nullptr);
+ {% for member in command.members if member.handle_type %}
+ {% set Type = member.handle_type.name.CamelCase() %}
+ {% set name = as_varName(member.name) %}
- auto* builtObject = mDevice->GetClient()->{{type.built_type.name.CamelCase()}}Allocator().GetObject(cmd.builtObject.id);
- uint32_t objectSerial = mDevice->GetClient()->{{type.built_type.name.CamelCase()}}Allocator().GetSerial(cmd.builtObject.id);
+ {% if member.type.dict_name == "ObjectHandle" %}
+ {{Type}}* {{name}} = {{Type}}Allocator().GetObject(cmd.{{name}}.id);
+ uint32_t {{name}}Serial = {{Type}}Allocator().GetSerial(cmd.{{name}}.id);
+ if ({{name}}Serial != cmd.{{name}}.serial) {
+ {{name}} = nullptr;
+ }
+ {% endif %}
+ {% endfor %}
- //* The object might have been deleted or a new object created with the same ID.
- if (builtObject == nullptr || objectSerial != cmd.builtObject.serial) {
- return true;
- }
-
- bool called = builtObject->builderCallback.Call(static_cast<dawnBuilderErrorStatus>(cmd.status), cmd.message);
-
- // Unhandled builder errors are forwarded to the device
- if (!called && cmd.status != DAWN_BUILDER_ERROR_STATUS_SUCCESS && cmd.status != DAWN_BUILDER_ERROR_STATUS_UNKNOWN) {
- mDevice->HandleError(("Unhandled builder error: " + std::string(cmd.message)).c_str());
- }
-
- return true;
+ return Do{{command.name.CamelCase()}}(
+ {%- for member in command.members -%}
+ {%- if member.handle_type -%}
+ {{as_varName(member.name)}}
+ {%- else -%}
+ cmd.{{as_varName(member.name)}}
+ {%- endif -%}
+ {%- if not loop.last -%}, {% endif %}
+ {%- endfor -%}
+ );
}
{% endfor %}
diff --git a/generator/templates/dawn_wire/client/ClientPrototypes.inl b/generator/templates/dawn_wire/client/ClientPrototypes.inl
index 5d64d85..6e47303 100644
--- a/generator/templates/dawn_wire/client/ClientPrototypes.inl
+++ b/generator/templates/dawn_wire/client/ClientPrototypes.inl
@@ -16,3 +16,17 @@
{% for command in cmd_records["return command"] %}
bool Handle{{command.name.CamelCase()}}(const char** commands, size_t* size);
{% endfor %}
+
+//* Return command doers
+{% for command in cmd_records["return command"] %}
+ bool Do{{command.name.CamelCase()}}(
+ {%- for member in command.members -%}
+ {%- if member.handle_type -%}
+ {{as_cppType(member.handle_type.name)}}* {{as_varName(member.name)}}
+ {%- else -%}
+ {{as_annotated_cppType(member)}}
+ {%- endif -%}
+ {%- if not loop.last -%}, {% endif %}
+ {%- endfor -%}
+ );
+{% endfor %}
diff --git a/generator/wire_cmd.py b/generator/wire_cmd.py
index 73669ca..d7198d5 100644
--- a/generator/wire_cmd.py
+++ b/generator/wire_cmd.py
@@ -27,13 +27,9 @@
commands = []
return_commands = []
- object_result_member = common.RecordMember(Name('result'), types['ObjectHandle'], 'value', False, True)
-
string_message_member = common.RecordMember(Name('message'), types['char'], 'const*', False, False)
string_message_member.length = 'strlen'
- built_object_member = common.RecordMember(Name('built object'), types['ObjectHandle'], 'value', False, False)
-
callback_status_member = common.RecordMember(Name('status'), types['uint32_t'], 'value', False, False)
# Generate commands from object methods
@@ -50,7 +46,9 @@
# Client->Server commands that return an object return the result object handle
if method.return_type.category == 'object':
- members.append(object_result_member)
+ result = common.RecordMember(Name('result'), types['ObjectHandle'], 'value', False, True)
+ result.set_handle_type(method.return_type)
+ members.append(result)
command_name = concat_names(api_object.name, method.name)
command = common.Command(command_name, members)
@@ -63,9 +61,10 @@
# This can be removed when WebGPU error handling is implemented
if api_object.is_builder:
command_name = concat_names(api_object.name, Name('error callback'))
-
+ built_object = common.RecordMember(Name('built object'), types['ObjectHandle'], 'value', False, False)
+ built_object.set_handle_type(api_object.built_type)
command = common.Command(command_name, [
- built_object_member,
+ built_object,
callback_status_member,
string_message_member,
])
diff --git a/src/dawn_wire/client/ApiProcs.cpp b/src/dawn_wire/client/ApiProcs.cpp
index d5a4494..084b2ed 100644
--- a/src/dawn_wire/client/ApiProcs.cpp
+++ b/src/dawn_wire/client/ApiProcs.cpp
@@ -105,25 +105,24 @@
fence->requests.Enqueue(std::move(request), value);
}
- void ProxyClientBufferUnmap(dawnBuffer cBuffer) {
+ void ClientBufferUnmap(dawnBuffer cBuffer) {
Buffer* buffer = reinterpret_cast<Buffer*>(cBuffer);
// Invalidate the local pointer, and cancel all other in-flight requests that would
- // turn into
- // errors anyway (you can't double map). This prevents race when the following happens,
- // where
- // the application code would have unmapped a buffer but still receive a callback:
- // - Client -> Server: MapRequest1, Unmap, MapRequest2
- // - Server -> Client: Result of MapRequest1
- // - Unmap locally on the client
- // - Server -> Client: Result of MapRequest2
+ // turn into errors anyway (you can't double map). This prevents race when the following
+ // happens, where the application code would have unmapped a buffer but still receive a
+ // callback:
+ // - Client -> Server: MapRequest1, Unmap, MapRequest2
+ // - Server -> Client: Result of MapRequest1
+ // - Unmap locally on the client
+ // - Server -> Client: Result of MapRequest2
if (buffer->mappedData) {
// If the buffer was mapped for writing, send the update to the data to the server
if (buffer->isWriteMapped) {
BufferUpdateMappedDataCmd cmd;
cmd.bufferId = buffer->id;
cmd.dataLength = static_cast<uint32_t>(buffer->mappedDataSize);
- cmd.data = reinterpret_cast<const uint8_t*>(buffer->mappedData);
+ cmd.data = static_cast<const uint8_t*>(buffer->mappedData);
size_t requiredSize = cmd.GetRequiredSize();
char* allocatedBuffer =
@@ -136,26 +135,52 @@
}
buffer->ClearMapRequests(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN);
- ClientBufferUnmap(cBuffer);
+ BufferUnmapCmd cmd;
+ cmd.self = cBuffer;
+ size_t requiredSize = cmd.GetRequiredSize();
+ char* allocatedBuffer =
+ static_cast<char*>(buffer->device->GetClient()->GetCmdSpace(requiredSize));
+ cmd.Serialize(allocatedBuffer, *buffer->device->GetClient());
}
- dawnFence ProxyClientDeviceCreateFence(dawnDevice cSelf,
- dawnFenceDescriptor const* descriptor) {
- dawnFence cFence = ClientDeviceCreateFence(cSelf, descriptor);
+ dawnFence ClientDeviceCreateFence(dawnDevice cSelf, dawnFenceDescriptor const* descriptor) {
+ Device* device = reinterpret_cast<Device*>(cSelf);
+
+ DeviceCreateFenceCmd cmd;
+ cmd.self = cSelf;
+ auto* allocation = device->GetClient()->FenceAllocator().New(device);
+ cmd.result = ObjectHandle{allocation->object->id, allocation->serial};
+ cmd.descriptor = descriptor;
+
+ size_t requiredSize = cmd.GetRequiredSize();
+ char* allocatedBuffer = static_cast<char*>(device->GetClient()->GetCmdSpace(requiredSize));
+ cmd.Serialize(allocatedBuffer, *device->GetClient());
+
+ dawnFence cFence = reinterpret_cast<dawnFence>(allocation->object.get());
+
Fence* fence = reinterpret_cast<Fence*>(cFence);
fence->signaledValue = descriptor->initialValue;
fence->completedValue = descriptor->initialValue;
return cFence;
}
- void ProxyClientQueueSignal(dawnQueue cQueue, dawnFence cFence, uint64_t signalValue) {
+ void ClientQueueSignal(dawnQueue cQueue, dawnFence cFence, uint64_t signalValue) {
Fence* fence = reinterpret_cast<Fence*>(cFence);
if (signalValue <= fence->signaledValue) {
fence->device->HandleError("Fence value less than or equal to signaled value");
return;
}
fence->signaledValue = signalValue;
- ClientQueueSignal(cQueue, cFence, signalValue);
+
+ QueueSignalCmd cmd;
+ cmd.self = cQueue;
+ cmd.fence = cFence;
+ cmd.signalValue = signalValue;
+
+ size_t requiredSize = cmd.GetRequiredSize();
+ char* allocatedBuffer =
+ static_cast<char*>(fence->device->GetClient()->GetCmdSpace(requiredSize));
+ cmd.Serialize(allocatedBuffer, *fence->device->GetClient());
}
void ClientDeviceReference(dawnDevice) {
diff --git a/src/dawn_wire/client/ClientDoers.cpp b/src/dawn_wire/client/ClientDoers.cpp
new file mode 100644
index 0000000..ea542e5
--- /dev/null
+++ b/src/dawn_wire/client/ClientDoers.cpp
@@ -0,0 +1,140 @@
+// 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 "common/Assert.h"
+#include "dawn_wire/client/Client.h"
+#include "dawn_wire/client/Device.h"
+
+namespace dawn_wire { namespace client {
+
+ bool Client::DoDeviceErrorCallback(const char* message) {
+ DAWN_ASSERT(message != nullptr);
+ mDevice->HandleError(message);
+ return true;
+ }
+
+ bool Client::DoBufferMapReadAsyncCallback(Buffer* buffer,
+ uint32_t requestSerial,
+ uint32_t status,
+ uint32_t count,
+ const uint8_t* data) {
+ // The buffer might have been deleted or recreated so this isn't an error.
+ if (buffer == nullptr) {
+ return true;
+ }
+
+ // The requests can have been deleted via an Unmap so this isn't an error.
+ auto requestIt = buffer->requests.find(requestSerial);
+ if (requestIt == buffer->requests.end()) {
+ return true;
+ }
+
+ // It is an error for the server to call the read callback when we asked for a map write
+ if (requestIt->second.isWrite) {
+ return false;
+ }
+
+ auto request = requestIt->second;
+ // Delete the request before calling the callback otherwise the callback could be fired a
+ // second time. If, for example, buffer.Unmap() is called inside the callback.
+ buffer->requests.erase(requestIt);
+
+ // On success, we copy the data locally because the IPC buffer isn't valid outside of this
+ // function
+ if (status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
+ // The server didn't send the right amount of data, this is an error and could cause
+ // the application to crash if we did call the callback.
+ if (request.size != count) {
+ return false;
+ }
+
+ ASSERT(data != nullptr);
+
+ if (buffer->mappedData != nullptr) {
+ return false;
+ }
+
+ buffer->isWriteMapped = false;
+ buffer->mappedDataSize = request.size;
+ buffer->mappedData = malloc(request.size);
+ memcpy(buffer->mappedData, data, request.size);
+
+ request.readCallback(static_cast<dawnBufferMapAsyncStatus>(status), buffer->mappedData,
+ request.userdata);
+ } else {
+ request.readCallback(static_cast<dawnBufferMapAsyncStatus>(status), nullptr,
+ request.userdata);
+ }
+
+ return true;
+ }
+
+ bool Client::DoBufferMapWriteAsyncCallback(Buffer* buffer,
+ uint32_t requestSerial,
+ uint32_t status) {
+ // The buffer might have been deleted or recreated so this isn't an error.
+ if (buffer == nullptr) {
+ return true;
+ }
+
+ // The requests can have been deleted via an Unmap so this isn't an error.
+ auto requestIt = buffer->requests.find(requestSerial);
+ if (requestIt == buffer->requests.end()) {
+ return true;
+ }
+
+ // It is an error for the server to call the write callback when we asked for a map read
+ if (!requestIt->second.isWrite) {
+ return false;
+ }
+
+ auto request = requestIt->second;
+ // Delete the request before calling the callback otherwise the callback could be fired a
+ // second time. If, for example, buffer.Unmap() is called inside the callback.
+ buffer->requests.erase(requestIt);
+
+ // On success, we copy the data locally because the IPC buffer isn't valid outside of this
+ // function
+ if (status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
+ if (buffer->mappedData != nullptr) {
+ return false;
+ }
+
+ buffer->isWriteMapped = true;
+ buffer->mappedDataSize = request.size;
+ buffer->mappedData = malloc(request.size);
+ memset(buffer->mappedData, 0, request.size);
+
+ request.writeCallback(static_cast<dawnBufferMapAsyncStatus>(status), buffer->mappedData,
+ request.userdata);
+ } else {
+ request.writeCallback(static_cast<dawnBufferMapAsyncStatus>(status), nullptr,
+ request.userdata);
+ }
+
+ return true;
+ }
+
+ bool Client::DoFenceUpdateCompletedValue(Fence* fence, uint64_t value) {
+ // The fence might have been deleted or recreated so this isn't an error.
+ if (fence == nullptr) {
+ return true;
+ }
+
+ fence->completedValue = value;
+ fence->CheckPassedFences();
+ return true;
+ }
+
+}} // namespace dawn_wire::client
diff --git a/src/dawn_wire/client/ClientHandlers.cpp b/src/dawn_wire/client/ClientHandlers.cpp
deleted file mode 100644
index 913b7a5..0000000
--- a/src/dawn_wire/client/ClientHandlers.cpp
+++ /dev/null
@@ -1,172 +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 "common/Assert.h"
-#include "dawn_wire/client/Client.h"
-#include "dawn_wire/client/Device.h"
-
-namespace dawn_wire { namespace client {
-
- bool Client::HandleDeviceErrorCallback(const char** commands, size_t* size) {
- ReturnDeviceErrorCallbackCmd cmd;
- DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
-
- if (deserializeResult == DeserializeResult::FatalError) {
- return false;
- }
-
- DAWN_ASSERT(cmd.message != nullptr);
- mDevice->HandleError(cmd.message);
-
- return true;
- }
-
- bool Client::HandleBufferMapReadAsyncCallback(const char** commands, size_t* size) {
- ReturnBufferMapReadAsyncCallbackCmd cmd;
- DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
-
- if (deserializeResult == DeserializeResult::FatalError) {
- return false;
- }
-
- auto* buffer = mDevice->GetClient()->BufferAllocator().GetObject(cmd.buffer.id);
- uint32_t bufferSerial = mDevice->GetClient()->BufferAllocator().GetSerial(cmd.buffer.id);
-
- // The buffer might have been deleted or recreated so this isn't an error.
- if (buffer == nullptr || bufferSerial != cmd.buffer.serial) {
- return true;
- }
-
- // The requests can have been deleted via an Unmap so this isn't an error.
- auto requestIt = buffer->requests.find(cmd.requestSerial);
- if (requestIt == buffer->requests.end()) {
- return true;
- }
-
- // It is an error for the server to call the read callback when we asked for a map write
- if (requestIt->second.isWrite) {
- return false;
- }
-
- auto request = requestIt->second;
- // Delete the request before calling the callback otherwise the callback could be fired a
- // second time. If, for example, buffer.Unmap() is called inside the callback.
- buffer->requests.erase(requestIt);
-
- // On success, we copy the data locally because the IPC buffer isn't valid outside of this
- // function
- if (cmd.status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
- // The server didn't send the right amount of data, this is an error and could cause
- // the application to crash if we did call the callback.
- if (request.size != cmd.dataLength) {
- return false;
- }
-
- ASSERT(cmd.data != nullptr);
-
- if (buffer->mappedData != nullptr) {
- return false;
- }
-
- buffer->isWriteMapped = false;
- buffer->mappedDataSize = request.size;
- buffer->mappedData = malloc(request.size);
- memcpy(buffer->mappedData, cmd.data, request.size);
-
- request.readCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status),
- buffer->mappedData, request.userdata);
- } else {
- request.readCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status), nullptr,
- request.userdata);
- }
-
- return true;
- }
-
- bool Client::HandleBufferMapWriteAsyncCallback(const char** commands, size_t* size) {
- ReturnBufferMapWriteAsyncCallbackCmd cmd;
- DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
-
- if (deserializeResult == DeserializeResult::FatalError) {
- return false;
- }
-
- auto* buffer = mDevice->GetClient()->BufferAllocator().GetObject(cmd.buffer.id);
- uint32_t bufferSerial = mDevice->GetClient()->BufferAllocator().GetSerial(cmd.buffer.id);
-
- // The buffer might have been deleted or recreated so this isn't an error.
- if (buffer == nullptr || bufferSerial != cmd.buffer.serial) {
- return true;
- }
-
- // The requests can have been deleted via an Unmap so this isn't an error.
- auto requestIt = buffer->requests.find(cmd.requestSerial);
- if (requestIt == buffer->requests.end()) {
- return true;
- }
-
- // It is an error for the server to call the write callback when we asked for a map read
- if (!requestIt->second.isWrite) {
- return false;
- }
-
- auto request = requestIt->second;
- // Delete the request before calling the callback otherwise the callback could be fired a
- // second time. If, for example, buffer.Unmap() is called inside the callback.
- buffer->requests.erase(requestIt);
-
- // On success, we copy the data locally because the IPC buffer isn't valid outside of this
- // function
- if (cmd.status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) {
- if (buffer->mappedData != nullptr) {
- return false;
- }
-
- buffer->isWriteMapped = true;
- buffer->mappedDataSize = request.size;
- buffer->mappedData = malloc(request.size);
- memset(buffer->mappedData, 0, request.size);
-
- request.writeCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status),
- buffer->mappedData, request.userdata);
- } else {
- request.writeCallback(static_cast<dawnBufferMapAsyncStatus>(cmd.status), nullptr,
- request.userdata);
- }
-
- return true;
- }
-
- bool Client::HandleFenceUpdateCompletedValue(const char** commands, size_t* size) {
- ReturnFenceUpdateCompletedValueCmd cmd;
- DeserializeResult deserializeResult = cmd.Deserialize(commands, size, &mAllocator);
-
- if (deserializeResult == DeserializeResult::FatalError) {
- return false;
- }
-
- auto* fence = mDevice->GetClient()->FenceAllocator().GetObject(cmd.fence.id);
- uint32_t fenceSerial = mDevice->GetClient()->FenceAllocator().GetSerial(cmd.fence.id);
-
- // The fence might have been deleted or recreated so this isn't an error.
- if (fence == nullptr || fenceSerial != cmd.fence.serial) {
- return true;
- }
-
- fence->completedValue = cmd.value;
- fence->CheckPassedFences();
- return true;
- }
-
-}} // namespace dawn_wire::client
