| // 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/server/Server.h" | |
| #include "dawn_wire/WireServer.h" | |
| namespace dawn_wire { namespace server { | |
| Server::Server(const DawnProcTable& procs, | |
| CommandSerializer* serializer, | |
| MemoryTransferService* memoryTransferService) | |
| : mSerializer(serializer), | |
| mProcs(procs), | |
| mMemoryTransferService(memoryTransferService), | |
| mIsAlive(std::make_shared<bool>(true)) { | |
| if (mMemoryTransferService == nullptr) { | |
| // If a MemoryTransferService is not provided, fallback to inline memory. | |
| mOwnedMemoryTransferService = CreateInlineMemoryTransferService(); | |
| mMemoryTransferService = mOwnedMemoryTransferService.get(); | |
| } | |
| } | |
| Server::~Server() { | |
| // Un-set the error and lost callbacks since we cannot forward them | |
| // after the server has been destroyed. | |
| for (WGPUDevice device : DeviceObjects().GetAllHandles()) { | |
| ClearDeviceCallbacks(device); | |
| } | |
| DestroyAllObjects(mProcs); | |
| } | |
| bool Server::InjectTexture(WGPUTexture texture, | |
| uint32_t id, | |
| uint32_t generation, | |
| uint32_t deviceId, | |
| uint32_t deviceGeneration) { | |
| ASSERT(texture != nullptr); | |
| ObjectData<WGPUDevice>* device = DeviceObjects().Get(deviceId); | |
| if (device == nullptr || device->generation != deviceGeneration) { | |
| return false; | |
| } | |
| ObjectData<WGPUTexture>* data = TextureObjects().Allocate(id); | |
| if (data == nullptr) { | |
| return false; | |
| } | |
| data->handle = texture; | |
| data->generation = generation; | |
| data->state = AllocationState::Allocated; | |
| data->deviceInfo = device->info.get(); | |
| if (!TrackDeviceChild(data->deviceInfo, ObjectType::Texture, id)) { | |
| return false; | |
| } | |
| // The texture is externally owned so it shouldn't be destroyed when we receive a destroy | |
| // message from the client. Add a reference to counterbalance the eventual release. | |
| mProcs.textureReference(texture); | |
| return true; | |
| } | |
| bool Server::InjectSwapChain(WGPUSwapChain swapchain, | |
| uint32_t id, | |
| uint32_t generation, | |
| uint32_t deviceId, | |
| uint32_t deviceGeneration) { | |
| ASSERT(swapchain != nullptr); | |
| ObjectData<WGPUDevice>* device = DeviceObjects().Get(deviceId); | |
| if (device == nullptr || device->generation != deviceGeneration) { | |
| return false; | |
| } | |
| ObjectData<WGPUSwapChain>* data = SwapChainObjects().Allocate(id); | |
| if (data == nullptr) { | |
| return false; | |
| } | |
| data->handle = swapchain; | |
| data->generation = generation; | |
| data->state = AllocationState::Allocated; | |
| data->deviceInfo = device->info.get(); | |
| if (!TrackDeviceChild(data->deviceInfo, ObjectType::SwapChain, id)) { | |
| return false; | |
| } | |
| // The texture is externally owned so it shouldn't be destroyed when we receive a destroy | |
| // message from the client. Add a reference to counterbalance the eventual release. | |
| mProcs.swapChainReference(swapchain); | |
| return true; | |
| } | |
| bool Server::InjectDevice(WGPUDevice device, uint32_t id, uint32_t generation) { | |
| ASSERT(device != nullptr); | |
| ObjectData<WGPUDevice>* data = DeviceObjects().Allocate(id); | |
| if (data == nullptr) { | |
| return false; | |
| } | |
| data->handle = device; | |
| data->generation = generation; | |
| data->state = AllocationState::Allocated; | |
| data->info->server = this; | |
| data->info->self = ObjectHandle{id, generation}; | |
| // The device is externally owned so it shouldn't be destroyed when we receive a destroy | |
| // message from the client. Add a reference to counterbalance the eventual release. | |
| mProcs.deviceReference(device); | |
| // Set callbacks to forward errors to the client. | |
| // Note: these callbacks are manually inlined here since they do not acquire and | |
| // free their userdata. Also unlike other callbacks, these are cleared and unset when | |
| // the server is destroyed, so we don't need to check if the server is still alive | |
| // inside them. | |
| mProcs.deviceSetUncapturedErrorCallback( | |
| device, | |
| [](WGPUErrorType type, const char* message, void* userdata) { | |
| DeviceInfo* info = static_cast<DeviceInfo*>(userdata); | |
| info->server->OnUncapturedError(info->self, type, message); | |
| }, | |
| data->info.get()); | |
| // Set callback to post warning and other infomation to client. | |
| // Almost the same with UncapturedError. | |
| mProcs.deviceSetLoggingCallback( | |
| device, | |
| [](WGPULoggingType type, const char* message, void* userdata) { | |
| DeviceInfo* info = static_cast<DeviceInfo*>(userdata); | |
| info->server->OnLogging(info->self, type, message); | |
| }, | |
| data->info.get()); | |
| mProcs.deviceSetDeviceLostCallback( | |
| device, | |
| [](WGPUDeviceLostReason reason, const char* message, void* userdata) { | |
| DeviceInfo* info = static_cast<DeviceInfo*>(userdata); | |
| info->server->OnDeviceLost(info->self, reason, message); | |
| }, | |
| data->info.get()); | |
| return true; | |
| } | |
| WGPUDevice Server::GetDevice(uint32_t id, uint32_t generation) { | |
| ObjectData<WGPUDevice>* data = DeviceObjects().Get(id); | |
| if (data == nullptr || data->generation != generation) { | |
| return nullptr; | |
| } | |
| return data->handle; | |
| } | |
| void Server::ClearDeviceCallbacks(WGPUDevice device) { | |
| // Un-set the error and lost callbacks since we cannot forward them | |
| // after the server has been destroyed. | |
| mProcs.deviceSetUncapturedErrorCallback(device, nullptr, nullptr); | |
| mProcs.deviceSetLoggingCallback(device, nullptr, nullptr); | |
| mProcs.deviceSetDeviceLostCallback(device, nullptr, nullptr); | |
| } | |
| bool TrackDeviceChild(DeviceInfo* info, ObjectType type, ObjectId id) { | |
| auto it = info->childObjectTypesAndIds.insert(PackObjectTypeAndId(type, id)); | |
| if (!it.second) { | |
| // An object of this type and id already exists. | |
| return false; | |
| } | |
| return true; | |
| } | |
| bool UntrackDeviceChild(DeviceInfo* info, ObjectType type, ObjectId id) { | |
| auto& children = info->childObjectTypesAndIds; | |
| auto it = children.find(PackObjectTypeAndId(type, id)); | |
| if (it == children.end()) { | |
| // An object of this type and id was already deleted. | |
| return false; | |
| } | |
| children.erase(it); | |
| return true; | |
| } | |
| }} // namespace dawn_wire::server |