Rename CreateReady*Pipeline to Create*PipelineAsync This follows the name change in the upstream WebGPU specification. Bug: dawn:529 Change-Id: I6d940dcc89f6b75136c642b578cb01bb8e40d681 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/41720 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org> Auto-Submit: Corentin Wallez <cwallez@chromium.org>
diff --git a/dawn.json b/dawn.json index afee3f3..d81172e 100644 --- a/dawn.json +++ b/dawn.json
@@ -597,16 +597,16 @@ {"name": "flipY", "type": "bool", "default": "false"} ] }, - "create ready compute pipeline callback": { + "create compute pipeline async callback": { "category": "callback", "args": [ - {"name": "status", "type": "create ready pipeline status"}, + {"name": "status", "type": "create pipeline async status"}, {"name": "pipeline", "type": "compute pipeline"}, {"name": "message", "type": "char", "annotation": "const*", "length": "strlen"}, {"name": "userdata", "type": "void", "annotation": "*"} ] }, - "create ready pipeline status": { + "create pipeline async status": { "category": "enum", "values": [ {"value": 0, "name": "success"}, @@ -616,10 +616,10 @@ {"value": 4, "name": "unknown"} ] }, - "create ready render pipeline callback": { + "create render pipeline async callback": { "category": "callback", "args": [ - {"name": "status", "type": "create ready pipeline status"}, + {"name": "status", "type": "create pipeline async status"}, {"name": "pipeline", "type": "render pipeline"}, {"name": "message", "type": "char", "annotation": "const*", "length": "strlen"}, {"name": "userdata", "type": "void", "annotation": "*"} @@ -677,11 +677,11 @@ ] }, { - "name": "create ready compute pipeline", + "name": "create compute pipeline async", "returns": "void", "args": [ {"name": "descriptor", "type": "compute pipeline descriptor", "annotation": "const*"}, - {"name": "callback", "type": "create ready compute pipeline callback"}, + {"name": "callback", "type": "create compute pipeline async callback"}, {"name": "userdata", "type": "void", "annotation": "*"} ] }, @@ -700,11 +700,11 @@ ] }, { - "name": "create ready render pipeline", + "name": "create render pipeline async", "returns": "void", "args": [ {"name": "descriptor", "type": "render pipeline descriptor", "annotation": "const*"}, - {"name": "callback", "type": "create ready render pipeline callback"}, + {"name": "callback", "type": "create render pipeline async callback"}, {"name": "userdata", "type": "void", "annotation": "*"} ] },
diff --git a/dawn_wire.json b/dawn_wire.json index 4294ed4..98b4596 100644 --- a/dawn_wire.json +++ b/dawn_wire.json
@@ -36,13 +36,13 @@ { "name": "handle create info length", "type": "uint64_t" }, { "name": "handle create info", "type": "uint8_t", "annotation": "const*", "length": "handle create info length", "skip_serialize": true} ], - "device create ready compute pipeline": [ + "device create compute pipeline async": [ { "name": "device id", "type": "ObjectId" }, { "name": "request serial", "type": "uint64_t" }, { "name": "pipeline object handle", "type": "ObjectHandle", "handle_type": "compute pipeline"}, { "name": "descriptor", "type": "compute pipeline descriptor", "annotation": "const*"} ], - "device create ready render pipeline": [ + "device create render pipeline async": [ { "name": "device id", "type": "ObjectId" }, { "name": "request serial", "type": "uint64_t" }, { "name": "pipeline object handle", "type": "ObjectHandle", "handle_type": "render pipeline"}, @@ -85,16 +85,16 @@ { "name": "read initial data info length", "type": "uint64_t" }, { "name": "read initial data info", "type": "uint8_t", "annotation": "const*", "length": "read initial data info length", "skip_serialize": true } ], - "device create ready compute pipeline callback": [ + "device create compute pipeline async callback": [ { "name": "device", "type": "ObjectHandle", "handle_type": "device" }, { "name": "request serial", "type": "uint64_t" }, - { "name": "status", "type": "create ready pipeline status" }, + { "name": "status", "type": "create pipeline async status" }, { "name": "message", "type": "char", "annotation": "const*", "length": "strlen" } ], - "device create ready render pipeline callback": [ + "device create render pipeline async callback": [ { "name": "device", "type": "ObjectHandle", "handle_type": "device" }, { "name": "request serial", "type": "uint64_t" }, - { "name": "status", "type": "create ready pipeline status" }, + { "name": "status", "type": "create pipeline async status" }, { "name": "message", "type": "char", "annotation": "const*", "length": "strlen" } ], "device uncaptured error callback": [ @@ -133,8 +133,8 @@ "BufferGetConstMappedRange", "BufferGetMappedRange", "DeviceCreateBuffer", - "DeviceCreateReadyComputePipeline", - "DeviceCreateReadyRenderPipeline", + "DeviceCreateComputePipelineAsync", + "DeviceCreateRenderPipelineAsync", "DevicePopErrorScope", "DeviceSetDeviceLostCallback", "DeviceSetUncapturedErrorCallback",
diff --git a/src/dawn_native/BUILD.gn b/src/dawn_native/BUILD.gn index 77afa36..b708e66 100644 --- a/src/dawn_native/BUILD.gn +++ b/src/dawn_native/BUILD.gn
@@ -199,8 +199,8 @@ "ComputePipeline.h", "CopyTextureForBrowserHelper.cpp", "CopyTextureForBrowserHelper.h", - "CreateReadyPipelineTracker.cpp", - "CreateReadyPipelineTracker.h", + "CreatePipelineAsyncTracker.cpp", + "CreatePipelineAsyncTracker.h", "Device.cpp", "Device.h", "DynamicUploader.cpp",
diff --git a/src/dawn_native/CMakeLists.txt b/src/dawn_native/CMakeLists.txt index 91c474c..ea3684e 100644 --- a/src/dawn_native/CMakeLists.txt +++ b/src/dawn_native/CMakeLists.txt
@@ -72,8 +72,8 @@ "ComputePipeline.h" "CopyTextureForBrowserHelper.cpp" "CopyTextureForBrowserHelper.h" - "CreateReadyPipelineTracker.cpp" - "CreateReadyPipelineTracker.h" + "CreatePipelineAsyncTracker.cpp" + "CreatePipelineAsyncTracker.h" "Device.cpp" "Device.h" "DynamicUploader.cpp"
diff --git a/src/dawn_native/CreatePipelineAsyncTracker.cpp b/src/dawn_native/CreatePipelineAsyncTracker.cpp new file mode 100644 index 0000000..7239774 --- /dev/null +++ b/src/dawn_native/CreatePipelineAsyncTracker.cpp
@@ -0,0 +1,114 @@ +// Copyright 2020 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_native/CreatePipelineAsyncTracker.h" + +#include "dawn_native/ComputePipeline.h" +#include "dawn_native/Device.h" +#include "dawn_native/RenderPipeline.h" + +namespace dawn_native { + + CreatePipelineAsyncTaskBase::CreatePipelineAsyncTaskBase(void* userdata) : mUserData(userdata) { + } + + CreatePipelineAsyncTaskBase::~CreatePipelineAsyncTaskBase() { + } + + CreateComputePipelineAsyncTask::CreateComputePipelineAsyncTask( + ComputePipelineBase* pipeline, + WGPUCreateComputePipelineAsyncCallback callback, + void* userdata) + : CreatePipelineAsyncTaskBase(userdata), + mPipeline(pipeline), + mCreateComputePipelineAsyncCallback(callback) { + } + + void CreateComputePipelineAsyncTask::Finish(WGPUCreatePipelineAsyncStatus status) { + ASSERT(mPipeline != nullptr); + ASSERT(mCreateComputePipelineAsyncCallback != nullptr); + + if (status != WGPUCreatePipelineAsyncStatus_Success) { + // TODO(jiawei.shao@intel.com): support handling device lost + ASSERT(status == WGPUCreatePipelineAsyncStatus_DeviceDestroyed); + mCreateComputePipelineAsyncCallback(WGPUCreatePipelineAsyncStatus_DeviceDestroyed, + nullptr, "Device destroyed before callback", + mUserData); + mPipeline->Release(); + } else { + mCreateComputePipelineAsyncCallback( + status, reinterpret_cast<WGPUComputePipeline>(mPipeline), "", mUserData); + } + + // Set mCreateComputePipelineAsyncCallback to nullptr in case it is called more than once. + mCreateComputePipelineAsyncCallback = nullptr; + } + + CreateRenderPipelineAsyncTask::CreateRenderPipelineAsyncTask( + RenderPipelineBase* pipeline, + WGPUCreateRenderPipelineAsyncCallback callback, + void* userdata) + : CreatePipelineAsyncTaskBase(userdata), + mPipeline(pipeline), + mCreateRenderPipelineAsyncCallback(callback) { + } + + void CreateRenderPipelineAsyncTask::Finish(WGPUCreatePipelineAsyncStatus status) { + ASSERT(mPipeline != nullptr); + ASSERT(mCreateRenderPipelineAsyncCallback != nullptr); + + if (status != WGPUCreatePipelineAsyncStatus_Success) { + // TODO(jiawei.shao@intel.com): support handling device lost + ASSERT(status == WGPUCreatePipelineAsyncStatus_DeviceDestroyed); + mCreateRenderPipelineAsyncCallback(WGPUCreatePipelineAsyncStatus_DeviceDestroyed, + nullptr, "Device destroyed before callback", + mUserData); + mPipeline->Release(); + } else { + mCreateRenderPipelineAsyncCallback( + status, reinterpret_cast<WGPURenderPipeline>(mPipeline), "", mUserData); + } + + // Set mCreatePipelineAsyncCallback to nullptr in case it is called more than once. + mCreateRenderPipelineAsyncCallback = nullptr; + } + + CreatePipelineAsyncTracker::CreatePipelineAsyncTracker(DeviceBase* device) : mDevice(device) { + } + + CreatePipelineAsyncTracker::~CreatePipelineAsyncTracker() { + ASSERT(mCreatePipelineAsyncTasksInFlight.Empty()); + } + + void CreatePipelineAsyncTracker::TrackTask(std::unique_ptr<CreatePipelineAsyncTaskBase> task, + ExecutionSerial serial) { + mCreatePipelineAsyncTasksInFlight.Enqueue(std::move(task), serial); + mDevice->AddFutureSerial(serial); + } + + void CreatePipelineAsyncTracker::Tick(ExecutionSerial finishedSerial) { + for (auto& task : mCreatePipelineAsyncTasksInFlight.IterateUpTo(finishedSerial)) { + task->Finish(WGPUCreatePipelineAsyncStatus_Success); + } + mCreatePipelineAsyncTasksInFlight.ClearUpTo(finishedSerial); + } + + void CreatePipelineAsyncTracker::ClearForShutDown() { + for (auto& task : mCreatePipelineAsyncTasksInFlight.IterateAll()) { + task->Finish(WGPUCreatePipelineAsyncStatus_DeviceDestroyed); + } + mCreatePipelineAsyncTasksInFlight.Clear(); + } + +} // namespace dawn_native
diff --git a/src/dawn_native/CreatePipelineAsyncTracker.h b/src/dawn_native/CreatePipelineAsyncTracker.h new file mode 100644 index 0000000..73e366c --- /dev/null +++ b/src/dawn_native/CreatePipelineAsyncTracker.h
@@ -0,0 +1,82 @@ +// Copyright 2020 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. + +#ifndef DAWNNATIVE_CREATEPIPELINEASYNCTRACKER_H_ +#define DAWNNATIVE_CREATEPIPELINEASYNCTRACKER_H_ + +#include "common/SerialQueue.h" +#include "dawn/webgpu.h" +#include "dawn_native/IntegerTypes.h" + +#include <memory> + +namespace dawn_native { + + class ComputePipelineBase; + class DeviceBase; + class PipelineBase; + class RenderPipelineBase; + + struct CreatePipelineAsyncTaskBase { + CreatePipelineAsyncTaskBase(void* userData); + virtual ~CreatePipelineAsyncTaskBase(); + + virtual void Finish(WGPUCreatePipelineAsyncStatus status) = 0; + + protected: + void* mUserData; + }; + + struct CreateComputePipelineAsyncTask final : public CreatePipelineAsyncTaskBase { + CreateComputePipelineAsyncTask(ComputePipelineBase* pipeline, + WGPUCreateComputePipelineAsyncCallback callback, + void* userdata); + + void Finish(WGPUCreatePipelineAsyncStatus status) final; + + private: + ComputePipelineBase* mPipeline; + WGPUCreateComputePipelineAsyncCallback mCreateComputePipelineAsyncCallback; + }; + + struct CreateRenderPipelineAsyncTask final : public CreatePipelineAsyncTaskBase { + CreateRenderPipelineAsyncTask(RenderPipelineBase* pipeline, + WGPUCreateRenderPipelineAsyncCallback callback, + void* userdata); + + void Finish(WGPUCreatePipelineAsyncStatus status) final; + + private: + RenderPipelineBase* mPipeline; + WGPUCreateRenderPipelineAsyncCallback mCreateRenderPipelineAsyncCallback; + }; + + class CreatePipelineAsyncTracker { + public: + CreatePipelineAsyncTracker(DeviceBase* device); + ~CreatePipelineAsyncTracker(); + + void TrackTask(std::unique_ptr<CreatePipelineAsyncTaskBase> task, ExecutionSerial serial); + void Tick(ExecutionSerial finishedSerial); + void ClearForShutDown(); + + private: + DeviceBase* mDevice; + SerialQueue<ExecutionSerial, std::unique_ptr<CreatePipelineAsyncTaskBase>> + mCreatePipelineAsyncTasksInFlight; + }; + +} // namespace dawn_native + +#endif // DAWNNATIVE_CREATEPIPELINEASYNCTRACKER_H_
diff --git a/src/dawn_native/CreateReadyPipelineTracker.cpp b/src/dawn_native/CreateReadyPipelineTracker.cpp deleted file mode 100644 index be64393..0000000 --- a/src/dawn_native/CreateReadyPipelineTracker.cpp +++ /dev/null
@@ -1,114 +0,0 @@ -// Copyright 2020 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_native/CreateReadyPipelineTracker.h" - -#include "dawn_native/ComputePipeline.h" -#include "dawn_native/Device.h" -#include "dawn_native/RenderPipeline.h" - -namespace dawn_native { - - CreateReadyPipelineTaskBase::CreateReadyPipelineTaskBase(void* userdata) : mUserData(userdata) { - } - - CreateReadyPipelineTaskBase::~CreateReadyPipelineTaskBase() { - } - - CreateReadyComputePipelineTask::CreateReadyComputePipelineTask( - ComputePipelineBase* pipeline, - WGPUCreateReadyComputePipelineCallback callback, - void* userdata) - : CreateReadyPipelineTaskBase(userdata), - mPipeline(pipeline), - mCreateReadyComputePipelineCallback(callback) { - } - - void CreateReadyComputePipelineTask::Finish(WGPUCreateReadyPipelineStatus status) { - ASSERT(mPipeline != nullptr); - ASSERT(mCreateReadyComputePipelineCallback != nullptr); - - if (status != WGPUCreateReadyPipelineStatus_Success) { - // TODO(jiawei.shao@intel.com): support handling device lost - ASSERT(status == WGPUCreateReadyPipelineStatus_DeviceDestroyed); - mCreateReadyComputePipelineCallback(WGPUCreateReadyPipelineStatus_DeviceDestroyed, - nullptr, "Device destroyed before callback", - mUserData); - mPipeline->Release(); - } else { - mCreateReadyComputePipelineCallback( - status, reinterpret_cast<WGPUComputePipeline>(mPipeline), "", mUserData); - } - - // Set mCreateReadyComputePipelineCallback to nullptr in case it is called more than once. - mCreateReadyComputePipelineCallback = nullptr; - } - - CreateReadyRenderPipelineTask::CreateReadyRenderPipelineTask( - RenderPipelineBase* pipeline, - WGPUCreateReadyRenderPipelineCallback callback, - void* userdata) - : CreateReadyPipelineTaskBase(userdata), - mPipeline(pipeline), - mCreateReadyRenderPipelineCallback(callback) { - } - - void CreateReadyRenderPipelineTask::Finish(WGPUCreateReadyPipelineStatus status) { - ASSERT(mPipeline != nullptr); - ASSERT(mCreateReadyRenderPipelineCallback != nullptr); - - if (status != WGPUCreateReadyPipelineStatus_Success) { - // TODO(jiawei.shao@intel.com): support handling device lost - ASSERT(status == WGPUCreateReadyPipelineStatus_DeviceDestroyed); - mCreateReadyRenderPipelineCallback(WGPUCreateReadyPipelineStatus_DeviceDestroyed, - nullptr, "Device destroyed before callback", - mUserData); - mPipeline->Release(); - } else { - mCreateReadyRenderPipelineCallback( - status, reinterpret_cast<WGPURenderPipeline>(mPipeline), "", mUserData); - } - - // Set mCreateReadyPipelineCallback to nullptr in case it is called more than once. - mCreateReadyRenderPipelineCallback = nullptr; - } - - CreateReadyPipelineTracker::CreateReadyPipelineTracker(DeviceBase* device) : mDevice(device) { - } - - CreateReadyPipelineTracker::~CreateReadyPipelineTracker() { - ASSERT(mCreateReadyPipelineTasksInFlight.Empty()); - } - - void CreateReadyPipelineTracker::TrackTask(std::unique_ptr<CreateReadyPipelineTaskBase> task, - ExecutionSerial serial) { - mCreateReadyPipelineTasksInFlight.Enqueue(std::move(task), serial); - mDevice->AddFutureSerial(serial); - } - - void CreateReadyPipelineTracker::Tick(ExecutionSerial finishedSerial) { - for (auto& task : mCreateReadyPipelineTasksInFlight.IterateUpTo(finishedSerial)) { - task->Finish(WGPUCreateReadyPipelineStatus_Success); - } - mCreateReadyPipelineTasksInFlight.ClearUpTo(finishedSerial); - } - - void CreateReadyPipelineTracker::ClearForShutDown() { - for (auto& task : mCreateReadyPipelineTasksInFlight.IterateAll()) { - task->Finish(WGPUCreateReadyPipelineStatus_DeviceDestroyed); - } - mCreateReadyPipelineTasksInFlight.Clear(); - } - -} // namespace dawn_native
diff --git a/src/dawn_native/CreateReadyPipelineTracker.h b/src/dawn_native/CreateReadyPipelineTracker.h deleted file mode 100644 index b1eed08..0000000 --- a/src/dawn_native/CreateReadyPipelineTracker.h +++ /dev/null
@@ -1,82 +0,0 @@ -// Copyright 2020 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. - -#ifndef DAWNNATIVE_CREATEREADYPIPELINETRACKER_H_ -#define DAWNNATIVE_CREATEREADYPIPELINETRACKER_H_ - -#include "common/SerialQueue.h" -#include "dawn/webgpu.h" -#include "dawn_native/IntegerTypes.h" - -#include <memory> - -namespace dawn_native { - - class ComputePipelineBase; - class DeviceBase; - class PipelineBase; - class RenderPipelineBase; - - struct CreateReadyPipelineTaskBase { - CreateReadyPipelineTaskBase(void* userData); - virtual ~CreateReadyPipelineTaskBase(); - - virtual void Finish(WGPUCreateReadyPipelineStatus status) = 0; - - protected: - void* mUserData; - }; - - struct CreateReadyComputePipelineTask final : public CreateReadyPipelineTaskBase { - CreateReadyComputePipelineTask(ComputePipelineBase* pipeline, - WGPUCreateReadyComputePipelineCallback callback, - void* userdata); - - void Finish(WGPUCreateReadyPipelineStatus status) final; - - private: - ComputePipelineBase* mPipeline; - WGPUCreateReadyComputePipelineCallback mCreateReadyComputePipelineCallback; - }; - - struct CreateReadyRenderPipelineTask final : public CreateReadyPipelineTaskBase { - CreateReadyRenderPipelineTask(RenderPipelineBase* pipeline, - WGPUCreateReadyRenderPipelineCallback callback, - void* userdata); - - void Finish(WGPUCreateReadyPipelineStatus status) final; - - private: - RenderPipelineBase* mPipeline; - WGPUCreateReadyRenderPipelineCallback mCreateReadyRenderPipelineCallback; - }; - - class CreateReadyPipelineTracker { - public: - CreateReadyPipelineTracker(DeviceBase* device); - ~CreateReadyPipelineTracker(); - - void TrackTask(std::unique_ptr<CreateReadyPipelineTaskBase> task, ExecutionSerial serial); - void Tick(ExecutionSerial finishedSerial); - void ClearForShutDown(); - - private: - DeviceBase* mDevice; - SerialQueue<ExecutionSerial, std::unique_ptr<CreateReadyPipelineTaskBase>> - mCreateReadyPipelineTasksInFlight; - }; - -} // namespace dawn_native - -#endif
diff --git a/src/dawn_native/Device.cpp b/src/dawn_native/Device.cpp index d2fdd97..7e33e3f 100644 --- a/src/dawn_native/Device.cpp +++ b/src/dawn_native/Device.cpp
@@ -23,7 +23,7 @@ #include "dawn_native/CommandBuffer.h" #include "dawn_native/CommandEncoder.h" #include "dawn_native/ComputePipeline.h" -#include "dawn_native/CreateReadyPipelineTracker.h" +#include "dawn_native/CreatePipelineAsyncTracker.h" #include "dawn_native/DynamicUploader.h" #include "dawn_native/ErrorData.h" #include "dawn_native/ErrorScope.h" @@ -123,7 +123,7 @@ mCaches = std::make_unique<DeviceBase::Caches>(); mErrorScopeStack = std::make_unique<ErrorScopeStack>(); mDynamicUploader = std::make_unique<DynamicUploader>(this); - mCreateReadyPipelineTracker = std::make_unique<CreateReadyPipelineTracker>(this); + mCreatePipelineAsyncTracker = std::make_unique<CreatePipelineAsyncTracker>(this); mDeprecationWarnings = std::make_unique<DeprecationWarnings>(); mInternalPipelineStore = std::make_unique<InternalPipelineStore>(); mPersistentCache = std::make_unique<PersistentCache>(this); @@ -141,7 +141,7 @@ // Skip handling device facilities if they haven't even been created (or failed doing so) if (mState != State::BeingCreated) { // Reject all async pipeline creations. - mCreateReadyPipelineTracker->ClearForShutDown(); + mCreatePipelineAsyncTracker->ClearForShutDown(); } // Disconnect the device, depending on which state we are currently in. @@ -186,7 +186,7 @@ mState = State::Disconnected; mDynamicUploader = nullptr; - mCreateReadyPipelineTracker = nullptr; + mCreatePipelineAsyncTracker = nullptr; mPersistentCache = nullptr; mEmptyBindGroupLayout = nullptr; @@ -705,21 +705,21 @@ return result; } - void DeviceBase::CreateReadyComputePipeline(const ComputePipelineDescriptor* descriptor, - WGPUCreateReadyComputePipelineCallback callback, + void DeviceBase::CreateComputePipelineAsync(const ComputePipelineDescriptor* descriptor, + WGPUCreateComputePipelineAsyncCallback callback, void* userdata) { ComputePipelineBase* result = nullptr; MaybeError maybeError = CreateComputePipelineInternal(&result, descriptor); if (maybeError.IsError()) { std::unique_ptr<ErrorData> error = maybeError.AcquireError(); - callback(WGPUCreateReadyPipelineStatus_Error, nullptr, error->GetMessage().c_str(), + callback(WGPUCreatePipelineAsyncStatus_Error, nullptr, error->GetMessage().c_str(), userdata); return; } - std::unique_ptr<CreateReadyComputePipelineTask> request = - std::make_unique<CreateReadyComputePipelineTask>(result, callback, userdata); - mCreateReadyPipelineTracker->TrackTask(std::move(request), GetPendingCommandSerial()); + std::unique_ptr<CreateComputePipelineAsyncTask> request = + std::make_unique<CreateComputePipelineAsyncTask>(result, callback, userdata); + mCreatePipelineAsyncTracker->TrackTask(std::move(request), GetPendingCommandSerial()); } PipelineLayoutBase* DeviceBase::CreatePipelineLayout( const PipelineLayoutDescriptor* descriptor) { @@ -749,21 +749,21 @@ return result; } - void DeviceBase::CreateReadyRenderPipeline(const RenderPipelineDescriptor* descriptor, - WGPUCreateReadyRenderPipelineCallback callback, + void DeviceBase::CreateRenderPipelineAsync(const RenderPipelineDescriptor* descriptor, + WGPUCreateRenderPipelineAsyncCallback callback, void* userdata) { RenderPipelineBase* result = nullptr; MaybeError maybeError = CreateRenderPipelineInternal(&result, descriptor); if (maybeError.IsError()) { std::unique_ptr<ErrorData> error = maybeError.AcquireError(); - callback(WGPUCreateReadyPipelineStatus_Error, nullptr, error->GetMessage().c_str(), + callback(WGPUCreatePipelineAsyncStatus_Error, nullptr, error->GetMessage().c_str(), userdata); return; } - std::unique_ptr<CreateReadyRenderPipelineTask> request = - std::make_unique<CreateReadyRenderPipelineTask>(result, callback, userdata); - mCreateReadyPipelineTracker->TrackTask(std::move(request), GetPendingCommandSerial()); + std::unique_ptr<CreateRenderPipelineAsyncTask> request = + std::make_unique<CreateRenderPipelineAsyncTask>(result, callback, userdata); + mCreatePipelineAsyncTracker->TrackTask(std::move(request), GetPendingCommandSerial()); } RenderBundleEncoder* DeviceBase::CreateRenderBundleEncoder( const RenderBundleEncoderDescriptor* descriptor) { @@ -862,7 +862,7 @@ mDynamicUploader->Deallocate(mCompletedSerial); GetQueue()->Tick(mCompletedSerial); - mCreateReadyPipelineTracker->Tick(mCompletedSerial); + mCreatePipelineAsyncTracker->Tick(mCompletedSerial); } return !IsDeviceIdle();
diff --git a/src/dawn_native/Device.h b/src/dawn_native/Device.h index 3a830d9..7764ec6 100644 --- a/src/dawn_native/Device.h +++ b/src/dawn_native/Device.h
@@ -33,7 +33,7 @@ class AttachmentState; class AttachmentStateBlueprint; class BindGroupLayoutBase; - class CreateReadyPipelineTracker; + class CreatePipelineAsyncTracker; class DynamicUploader; class ErrorScopeStack; class PersistentCache; @@ -146,11 +146,11 @@ ComputePipelineBase* CreateComputePipeline(const ComputePipelineDescriptor* descriptor); PipelineLayoutBase* CreatePipelineLayout(const PipelineLayoutDescriptor* descriptor); QuerySetBase* CreateQuerySet(const QuerySetDescriptor* descriptor); - void CreateReadyComputePipeline(const ComputePipelineDescriptor* descriptor, - WGPUCreateReadyComputePipelineCallback callback, + void CreateComputePipelineAsync(const ComputePipelineDescriptor* descriptor, + WGPUCreateComputePipelineAsyncCallback callback, void* userdata); - void CreateReadyRenderPipeline(const RenderPipelineDescriptor* descriptor, - WGPUCreateReadyRenderPipelineCallback callback, + void CreateRenderPipelineAsync(const RenderPipelineDescriptor* descriptor, + WGPUCreateRenderPipelineAsyncCallback callback, void* userdata); RenderBundleEncoder* CreateRenderBundleEncoder( const RenderBundleEncoderDescriptor* descriptor); @@ -381,7 +381,7 @@ Ref<BindGroupLayoutBase> mEmptyBindGroupLayout; std::unique_ptr<DynamicUploader> mDynamicUploader; - std::unique_ptr<CreateReadyPipelineTracker> mCreateReadyPipelineTracker; + std::unique_ptr<CreatePipelineAsyncTracker> mCreatePipelineAsyncTracker; Ref<QueueBase> mQueue; struct DeprecationWarnings;
diff --git a/src/dawn_wire/client/ClientDoers.cpp b/src/dawn_wire/client/ClientDoers.cpp index d86d13e..a5ef7f6 100644 --- a/src/dawn_wire/client/ClientDoers.cpp +++ b/src/dawn_wire/client/ClientDoers.cpp
@@ -93,26 +93,26 @@ return true; } - bool Client::DoDeviceCreateReadyComputePipelineCallback(Device* device, + bool Client::DoDeviceCreateComputePipelineAsyncCallback(Device* device, uint64_t requestSerial, - WGPUCreateReadyPipelineStatus status, + WGPUCreatePipelineAsyncStatus status, const char* message) { // The device might have been deleted or recreated so this isn't an error. if (device == nullptr) { return true; } - return device->OnCreateReadyComputePipelineCallback(requestSerial, status, message); + return device->OnCreateComputePipelineAsyncCallback(requestSerial, status, message); } - bool Client::DoDeviceCreateReadyRenderPipelineCallback(Device* device, + bool Client::DoDeviceCreateRenderPipelineAsyncCallback(Device* device, uint64_t requestSerial, - WGPUCreateReadyPipelineStatus status, + WGPUCreatePipelineAsyncStatus status, const char* message) { // The device might have been deleted or recreated so this isn't an error. if (device == nullptr) { return true; } - return device->OnCreateReadyRenderPipelineCallback(requestSerial, status, message); + return device->OnCreateRenderPipelineAsyncCallback(requestSerial, status, message); } }} // namespace dawn_wire::client
diff --git a/src/dawn_wire/client/Device.cpp b/src/dawn_wire/client/Device.cpp index cbd661d..3a9189e 100644 --- a/src/dawn_wire/client/Device.cpp +++ b/src/dawn_wire/client/Device.cpp
@@ -55,16 +55,16 @@ it.second.userdata); } - auto createReadyPipelineRequests = std::move(mCreateReadyPipelineRequests); - for (const auto& it : createReadyPipelineRequests) { - if (it.second.createReadyComputePipelineCallback != nullptr) { - it.second.createReadyComputePipelineCallback( - WGPUCreateReadyPipelineStatus_DeviceDestroyed, nullptr, + auto createPipelineAsyncRequests = std::move(mCreatePipelineAsyncRequests); + for (const auto& it : createPipelineAsyncRequests) { + if (it.second.createComputePipelineAsyncCallback != nullptr) { + it.second.createComputePipelineAsyncCallback( + WGPUCreatePipelineAsyncStatus_DeviceDestroyed, nullptr, "Device destroyed before callback", it.second.userdata); } else { - ASSERT(it.second.createReadyRenderPipelineCallback != nullptr); - it.second.createReadyRenderPipelineCallback( - WGPUCreateReadyPipelineStatus_DeviceDestroyed, nullptr, + ASSERT(it.second.createRenderPipelineAsyncCallback != nullptr); + it.second.createRenderPipelineAsyncCallback( + WGPUCreatePipelineAsyncStatus_DeviceDestroyed, nullptr, "Device destroyed before callback", it.second.userdata); } } @@ -84,20 +84,20 @@ } void Device::CancelCallbacksForDisconnect() { - for (auto& it : mCreateReadyPipelineRequests) { - ASSERT((it.second.createReadyComputePipelineCallback != nullptr) ^ - (it.second.createReadyRenderPipelineCallback != nullptr)); - if (it.second.createReadyRenderPipelineCallback) { - it.second.createReadyRenderPipelineCallback( - WGPUCreateReadyPipelineStatus_DeviceLost, nullptr, "Device lost", + for (auto& it : mCreatePipelineAsyncRequests) { + ASSERT((it.second.createComputePipelineAsyncCallback != nullptr) ^ + (it.second.createRenderPipelineAsyncCallback != nullptr)); + if (it.second.createRenderPipelineAsyncCallback) { + it.second.createRenderPipelineAsyncCallback( + WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr, "Device lost", it.second.userdata); } else { - it.second.createReadyComputePipelineCallback( - WGPUCreateReadyPipelineStatus_DeviceLost, nullptr, "Device lost", + it.second.createComputePipelineAsyncCallback( + WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr, "Device lost", it.second.userdata); } } - mCreateReadyPipelineRequests.clear(); + mCreatePipelineAsyncRequests.clear(); for (auto& it : mErrorScopes) { it.second.callback(WGPUErrorType_DeviceLost, "Device lost", it.second.userdata); @@ -221,113 +221,113 @@ return GetQueue(); } - void Device::CreateReadyComputePipeline(WGPUComputePipelineDescriptor const* descriptor, - WGPUCreateReadyComputePipelineCallback callback, + void Device::CreateComputePipelineAsync(WGPUComputePipelineDescriptor const* descriptor, + WGPUCreateComputePipelineAsyncCallback callback, void* userdata) { if (client->IsDisconnected()) { - return callback(WGPUCreateReadyPipelineStatus_DeviceLost, nullptr, + return callback(WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr, "GPU device disconnected", userdata); } - DeviceCreateReadyComputePipelineCmd cmd; + DeviceCreateComputePipelineAsyncCmd cmd; cmd.deviceId = this->id; cmd.descriptor = descriptor; - uint64_t serial = mCreateReadyPipelineRequestSerial++; - ASSERT(mCreateReadyPipelineRequests.find(serial) == mCreateReadyPipelineRequests.end()); + uint64_t serial = mCreatePipelineAsyncRequestSerial++; + ASSERT(mCreatePipelineAsyncRequests.find(serial) == mCreatePipelineAsyncRequests.end()); cmd.requestSerial = serial; auto* allocation = client->ComputePipelineAllocator().New(client); - CreateReadyPipelineRequest request = {}; - request.createReadyComputePipelineCallback = callback; + CreatePipelineAsyncRequest request = {}; + request.createComputePipelineAsyncCallback = callback; request.userdata = userdata; request.pipelineObjectID = allocation->object->id; cmd.pipelineObjectHandle = ObjectHandle{allocation->object->id, allocation->generation}; client->SerializeCommand(cmd); - mCreateReadyPipelineRequests[serial] = std::move(request); + mCreatePipelineAsyncRequests[serial] = std::move(request); } - bool Device::OnCreateReadyComputePipelineCallback(uint64_t requestSerial, - WGPUCreateReadyPipelineStatus status, + bool Device::OnCreateComputePipelineAsyncCallback(uint64_t requestSerial, + WGPUCreatePipelineAsyncStatus status, const char* message) { - const auto& requestIt = mCreateReadyPipelineRequests.find(requestSerial); - if (requestIt == mCreateReadyPipelineRequests.end()) { + const auto& requestIt = mCreatePipelineAsyncRequests.find(requestSerial); + if (requestIt == mCreatePipelineAsyncRequests.end()) { return false; } - CreateReadyPipelineRequest request = std::move(requestIt->second); - mCreateReadyPipelineRequests.erase(requestIt); + CreatePipelineAsyncRequest request = std::move(requestIt->second); + mCreatePipelineAsyncRequests.erase(requestIt); auto pipelineAllocation = client->ComputePipelineAllocator().GetObject(request.pipelineObjectID); // If the return status is a failure we should give a null pipeline to the callback and // free the allocation both on the client side and the server side. - if (status != WGPUCreateReadyPipelineStatus_Success) { + if (status != WGPUCreatePipelineAsyncStatus_Success) { client->ComputePipelineAllocator().Free(pipelineAllocation); - request.createReadyComputePipelineCallback(status, nullptr, message, request.userdata); + request.createComputePipelineAsyncCallback(status, nullptr, message, request.userdata); return true; } WGPUComputePipeline pipeline = reinterpret_cast<WGPUComputePipeline>(pipelineAllocation); - request.createReadyComputePipelineCallback(status, pipeline, message, request.userdata); + request.createComputePipelineAsyncCallback(status, pipeline, message, request.userdata); return true; } - void Device::CreateReadyRenderPipeline(WGPURenderPipelineDescriptor const* descriptor, - WGPUCreateReadyRenderPipelineCallback callback, + void Device::CreateRenderPipelineAsync(WGPURenderPipelineDescriptor const* descriptor, + WGPUCreateRenderPipelineAsyncCallback callback, void* userdata) { if (client->IsDisconnected()) { - return callback(WGPUCreateReadyPipelineStatus_DeviceLost, nullptr, + return callback(WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr, "GPU device disconnected", userdata); } - DeviceCreateReadyRenderPipelineCmd cmd; + DeviceCreateRenderPipelineAsyncCmd cmd; cmd.deviceId = this->id; cmd.descriptor = descriptor; - uint64_t serial = mCreateReadyPipelineRequestSerial++; - ASSERT(mCreateReadyPipelineRequests.find(serial) == mCreateReadyPipelineRequests.end()); + uint64_t serial = mCreatePipelineAsyncRequestSerial++; + ASSERT(mCreatePipelineAsyncRequests.find(serial) == mCreatePipelineAsyncRequests.end()); cmd.requestSerial = serial; auto* allocation = client->RenderPipelineAllocator().New(client); - CreateReadyPipelineRequest request = {}; - request.createReadyRenderPipelineCallback = callback; + CreatePipelineAsyncRequest request = {}; + request.createRenderPipelineAsyncCallback = callback; request.userdata = userdata; request.pipelineObjectID = allocation->object->id; cmd.pipelineObjectHandle = ObjectHandle(allocation->object->id, allocation->generation); client->SerializeCommand(cmd); - mCreateReadyPipelineRequests[serial] = std::move(request); + mCreatePipelineAsyncRequests[serial] = std::move(request); } - bool Device::OnCreateReadyRenderPipelineCallback(uint64_t requestSerial, - WGPUCreateReadyPipelineStatus status, + bool Device::OnCreateRenderPipelineAsyncCallback(uint64_t requestSerial, + WGPUCreatePipelineAsyncStatus status, const char* message) { - const auto& requestIt = mCreateReadyPipelineRequests.find(requestSerial); - if (requestIt == mCreateReadyPipelineRequests.end()) { + const auto& requestIt = mCreatePipelineAsyncRequests.find(requestSerial); + if (requestIt == mCreatePipelineAsyncRequests.end()) { return false; } - CreateReadyPipelineRequest request = std::move(requestIt->second); - mCreateReadyPipelineRequests.erase(requestIt); + CreatePipelineAsyncRequest request = std::move(requestIt->second); + mCreatePipelineAsyncRequests.erase(requestIt); auto pipelineAllocation = client->RenderPipelineAllocator().GetObject(request.pipelineObjectID); // If the return status is a failure we should give a null pipeline to the callback and // free the allocation both on the client side and the server side. - if (status != WGPUCreateReadyPipelineStatus_Success) { + if (status != WGPUCreatePipelineAsyncStatus_Success) { client->RenderPipelineAllocator().Free(pipelineAllocation); - request.createReadyRenderPipelineCallback(status, nullptr, message, request.userdata); + request.createRenderPipelineAsyncCallback(status, nullptr, message, request.userdata); return true; } WGPURenderPipeline pipeline = reinterpret_cast<WGPURenderPipeline>(pipelineAllocation); - request.createReadyRenderPipelineCallback(status, pipeline, message, request.userdata); + request.createRenderPipelineAsyncCallback(status, pipeline, message, request.userdata); return true; }
diff --git a/src/dawn_wire/client/Device.h b/src/dawn_wire/client/Device.h index 6e86dbe..c72200b 100644 --- a/src/dawn_wire/client/Device.h +++ b/src/dawn_wire/client/Device.h
@@ -42,11 +42,11 @@ bool PopErrorScope(WGPUErrorCallback callback, void* userdata); WGPUBuffer CreateBuffer(const WGPUBufferDescriptor* descriptor); WGPUBuffer CreateErrorBuffer(); - void CreateReadyComputePipeline(WGPUComputePipelineDescriptor const* descriptor, - WGPUCreateReadyComputePipelineCallback callback, + void CreateComputePipelineAsync(WGPUComputePipelineDescriptor const* descriptor, + WGPUCreateComputePipelineAsyncCallback callback, void* userdata); - void CreateReadyRenderPipeline(WGPURenderPipelineDescriptor const* descriptor, - WGPUCreateReadyRenderPipelineCallback callback, + void CreateRenderPipelineAsync(WGPURenderPipelineDescriptor const* descriptor, + WGPUCreateRenderPipelineAsyncCallback callback, void* userdata); void HandleError(WGPUErrorType errorType, const char* message); @@ -54,11 +54,11 @@ bool OnPopErrorScopeCallback(uint64_t requestSerial, WGPUErrorType type, const char* message); - bool OnCreateReadyComputePipelineCallback(uint64_t requestSerial, - WGPUCreateReadyPipelineStatus status, + bool OnCreateComputePipelineAsyncCallback(uint64_t requestSerial, + WGPUCreatePipelineAsyncStatus status, const char* message); - bool OnCreateReadyRenderPipelineCallback(uint64_t requestSerial, - WGPUCreateReadyPipelineStatus status, + bool OnCreateRenderPipelineAsyncCallback(uint64_t requestSerial, + WGPUCreatePipelineAsyncStatus status, const char* message); // TODO(dawn:22): Remove once the deprecation period is finished. @@ -78,14 +78,14 @@ uint64_t mErrorScopeRequestSerial = 0; uint64_t mErrorScopeStackSize = 0; - struct CreateReadyPipelineRequest { - WGPUCreateReadyComputePipelineCallback createReadyComputePipelineCallback = nullptr; - WGPUCreateReadyRenderPipelineCallback createReadyRenderPipelineCallback = nullptr; + struct CreatePipelineAsyncRequest { + WGPUCreateComputePipelineAsyncCallback createComputePipelineAsyncCallback = nullptr; + WGPUCreateRenderPipelineAsyncCallback createRenderPipelineAsyncCallback = nullptr; void* userdata = nullptr; ObjectId pipelineObjectID; }; - std::map<uint64_t, CreateReadyPipelineRequest> mCreateReadyPipelineRequests; - uint64_t mCreateReadyPipelineRequestSerial = 0; + std::map<uint64_t, CreatePipelineAsyncRequest> mCreatePipelineAsyncRequests; + uint64_t mCreatePipelineAsyncRequestSerial = 0; WGPUErrorCallback mErrorCallback = nullptr; WGPUDeviceLostCallback mDeviceLostCallback = nullptr;
diff --git a/src/dawn_wire/server/Server.h b/src/dawn_wire/server/Server.h index 90d29c4..bcedeaa 100644 --- a/src/dawn_wire/server/Server.h +++ b/src/dawn_wire/server/Server.h
@@ -141,7 +141,7 @@ uint64_t requestSerial; }; - struct CreateReadyPipelineUserData : CallbackUserdata { + struct CreatePipelineAsyncUserData : CallbackUserdata { using CallbackUserdata::CallbackUserdata; ObjectHandle device; @@ -202,14 +202,14 @@ FenceCompletionUserdata* userdata); void OnFenceOnCompletion(WGPUFenceCompletionStatus status, FenceOnCompletionUserdata* userdata); - void OnCreateReadyComputePipelineCallback(WGPUCreateReadyPipelineStatus status, + void OnCreateComputePipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline, const char* message, - CreateReadyPipelineUserData* userdata); - void OnCreateReadyRenderPipelineCallback(WGPUCreateReadyPipelineStatus status, + CreatePipelineAsyncUserData* userdata); + void OnCreateRenderPipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline, const char* message, - CreateReadyPipelineUserData* userdata); + CreatePipelineAsyncUserData* userdata); #include "dawn_wire/server/ServerPrototypes_autogen.inc"
diff --git a/src/dawn_wire/server/ServerDevice.cpp b/src/dawn_wire/server/ServerDevice.cpp index bcc8db6..19e6298 100644 --- a/src/dawn_wire/server/ServerDevice.cpp +++ b/src/dawn_wire/server/ServerDevice.cpp
@@ -19,10 +19,10 @@ namespace { template <ObjectType objectType, typename Pipeline> - void HandleCreateReadyRenderPipelineCallbackResult(KnownObjects<Pipeline>* knownObjects, - WGPUCreateReadyPipelineStatus status, + void HandleCreateRenderPipelineAsyncCallbackResult(KnownObjects<Pipeline>* knownObjects, + WGPUCreatePipelineAsyncStatus status, Pipeline pipeline, - CreateReadyPipelineUserData* data) { + CreatePipelineAsyncUserData* data) { // May be null if the device was destroyed. Device destruction destroys child // objects on the wire. auto* pipelineObject = @@ -31,7 +31,7 @@ // they move from Reserved to Allocated, or if they are destroyed here. ASSERT(pipelineObject != nullptr); - if (status == WGPUCreateReadyPipelineStatus_Success) { + if (status == WGPUCreatePipelineAsyncStatus_Success) { // Assign the handle and allocated status if the pipeline is created successfully. pipelineObject->state = AllocationState::Allocated; pipelineObject->handle = pipeline; @@ -101,7 +101,7 @@ SerializeCommand(cmd); } - bool Server::DoDeviceCreateReadyComputePipeline( + bool Server::DoDeviceCreateComputePipelineAsync( ObjectId deviceId, uint64_t requestSerial, ObjectHandle pipelineObjectHandle, @@ -120,27 +120,27 @@ resultData->generation = pipelineObjectHandle.generation; resultData->deviceInfo = device->info.get(); - auto userdata = MakeUserdata<CreateReadyPipelineUserData>(); + auto userdata = MakeUserdata<CreatePipelineAsyncUserData>(); userdata->device = ObjectHandle{deviceId, device->generation}; userdata->requestSerial = requestSerial; userdata->pipelineObjectID = pipelineObjectHandle.id; - mProcs.deviceCreateReadyComputePipeline( + mProcs.deviceCreateComputePipelineAsync( device->handle, descriptor, - ForwardToServer<decltype(&Server::OnCreateReadyComputePipelineCallback)>::Func< - &Server::OnCreateReadyComputePipelineCallback>(), + ForwardToServer<decltype(&Server::OnCreateComputePipelineAsyncCallback)>::Func< + &Server::OnCreateComputePipelineAsyncCallback>(), userdata.release()); return true; } - void Server::OnCreateReadyComputePipelineCallback(WGPUCreateReadyPipelineStatus status, + void Server::OnCreateComputePipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline, const char* message, - CreateReadyPipelineUserData* data) { - HandleCreateReadyRenderPipelineCallbackResult<ObjectType::ComputePipeline>( + CreatePipelineAsyncUserData* data) { + HandleCreateRenderPipelineAsyncCallbackResult<ObjectType::ComputePipeline>( &ComputePipelineObjects(), status, pipeline, data); - ReturnDeviceCreateReadyComputePipelineCallbackCmd cmd; + ReturnDeviceCreateComputePipelineAsyncCallbackCmd cmd; cmd.device = data->device; cmd.status = status; cmd.requestSerial = data->requestSerial; @@ -149,7 +149,7 @@ SerializeCommand(cmd); } - bool Server::DoDeviceCreateReadyRenderPipeline(ObjectId deviceId, + bool Server::DoDeviceCreateRenderPipelineAsync(ObjectId deviceId, uint64_t requestSerial, ObjectHandle pipelineObjectHandle, const WGPURenderPipelineDescriptor* descriptor) { @@ -167,27 +167,27 @@ resultData->generation = pipelineObjectHandle.generation; resultData->deviceInfo = device->info.get(); - auto userdata = MakeUserdata<CreateReadyPipelineUserData>(); + auto userdata = MakeUserdata<CreatePipelineAsyncUserData>(); userdata->device = ObjectHandle{deviceId, device->generation}; userdata->requestSerial = requestSerial; userdata->pipelineObjectID = pipelineObjectHandle.id; - mProcs.deviceCreateReadyRenderPipeline( + mProcs.deviceCreateRenderPipelineAsync( device->handle, descriptor, - ForwardToServer<decltype(&Server::OnCreateReadyRenderPipelineCallback)>::Func< - &Server::OnCreateReadyRenderPipelineCallback>(), + ForwardToServer<decltype(&Server::OnCreateRenderPipelineAsyncCallback)>::Func< + &Server::OnCreateRenderPipelineAsyncCallback>(), userdata.release()); return true; } - void Server::OnCreateReadyRenderPipelineCallback(WGPUCreateReadyPipelineStatus status, + void Server::OnCreateRenderPipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline, const char* message, - CreateReadyPipelineUserData* data) { - HandleCreateReadyRenderPipelineCallbackResult<ObjectType::RenderPipeline>( + CreatePipelineAsyncUserData* data) { + HandleCreateRenderPipelineAsyncCallbackResult<ObjectType::RenderPipeline>( &RenderPipelineObjects(), status, pipeline, data); - ReturnDeviceCreateReadyRenderPipelineCallbackCmd cmd; + ReturnDeviceCreateRenderPipelineAsyncCallbackCmd cmd; cmd.device = data->device; cmd.status = status; cmd.requestSerial = data->requestSerial;
diff --git a/src/tests/BUILD.gn b/src/tests/BUILD.gn index efc2aee..0c3ffc3 100644 --- a/src/tests/BUILD.gn +++ b/src/tests/BUILD.gn
@@ -221,7 +221,7 @@ "unittests/wire/WireArgumentTests.cpp", "unittests/wire/WireBasicTests.cpp", "unittests/wire/WireBufferMappingTests.cpp", - "unittests/wire/WireCreateReadyPipelineTests.cpp", + "unittests/wire/WireCreatePipelineAsyncTests.cpp", "unittests/wire/WireDestroyObjectTests.cpp", "unittests/wire/WireDisconnectTests.cpp", "unittests/wire/WireErrorCallbackTests.cpp", @@ -283,7 +283,7 @@ "end2end/ComputeStorageBufferBarrierTests.cpp", "end2end/CopyTests.cpp", "end2end/CopyTextureForBrowserTests.cpp", - "end2end/CreateReadyPipelineTests.cpp", + "end2end/CreatePipelineAsyncTests.cpp", "end2end/CullingTests.cpp", "end2end/DebugMarkerTests.cpp", "end2end/DeprecatedAPITests.cpp",
diff --git a/src/tests/end2end/CreateReadyPipelineTests.cpp b/src/tests/end2end/CreatePipelineAsyncTests.cpp similarity index 77% rename from src/tests/end2end/CreateReadyPipelineTests.cpp rename to src/tests/end2end/CreatePipelineAsyncTests.cpp index a10d208..ef6307c 100644 --- a/src/tests/end2end/CreateReadyPipelineTests.cpp +++ b/src/tests/end2end/CreatePipelineAsyncTests.cpp
@@ -18,7 +18,7 @@ #include "utils/WGPUHelpers.h" namespace { - struct CreateReadyPipelineTask { + struct CreatePipelineAsyncTask { wgpu::ComputePipeline computePipeline = nullptr; wgpu::RenderPipeline renderPipeline = nullptr; bool isCompleted = false; @@ -26,13 +26,13 @@ }; } // anonymous namespace -class CreateReadyPipelineTest : public DawnTest { +class CreatePipelineAsyncTest : public DawnTest { protected: - CreateReadyPipelineTask task; + CreatePipelineAsyncTask task; }; -// Verify the basic use of CreateReadyComputePipeline works on all backends. -TEST_P(CreateReadyPipelineTest, BasicUseOfCreateReadyComputePipeline) { +// Verify the basic use of CreateComputePipelineAsync works on all backends. +TEST_P(CreatePipelineAsyncTest, BasicUseOfCreateComputePipelineAsync) { wgpu::ComputePipelineDescriptor csDesc; csDesc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, R"( [[block]] struct SSBO { @@ -45,13 +45,13 @@ })"); csDesc.computeStage.entryPoint = "main"; - device.CreateReadyComputePipeline( + device.CreateComputePipelineAsync( &csDesc, - [](WGPUCreateReadyPipelineStatus status, WGPUComputePipeline returnPipeline, + [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline returnPipeline, const char* message, void* userdata) { - EXPECT_EQ(WGPUCreateReadyPipelineStatus::WGPUCreateReadyPipelineStatus_Success, status); + EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Success, status); - CreateReadyPipelineTask* task = static_cast<CreateReadyPipelineTask*>(userdata); + CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); task->computePipeline = wgpu::ComputePipeline::Acquire(returnPipeline); task->isCompleted = true; task->message = message; @@ -93,11 +93,11 @@ EXPECT_BUFFER_U32_EQ(kExpected, ssbo, 0); } -// Verify CreateReadyComputePipeline() works as expected when there is any error that happens during +// Verify CreateComputePipelineAsync() works as expected when there is any error that happens during // the creation of the compute pipeline. The SPEC requires that during the call of -// CreateReadyComputePipeline() any error won't be forwarded to the error scope / unhandled error +// CreateComputePipelineAsync() any error won't be forwarded to the error scope / unhandled error // callback. -TEST_P(CreateReadyPipelineTest, CreateComputePipelineFailed) { +TEST_P(CreatePipelineAsyncTest, CreateComputePipelineFailed) { DAWN_SKIP_TEST_IF(HasToggleEnabled("skip_validation")); wgpu::ComputePipelineDescriptor csDesc; @@ -112,13 +112,13 @@ })"); csDesc.computeStage.entryPoint = "main0"; - device.CreateReadyComputePipeline( + device.CreateComputePipelineAsync( &csDesc, - [](WGPUCreateReadyPipelineStatus status, WGPUComputePipeline returnPipeline, + [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline returnPipeline, const char* message, void* userdata) { - EXPECT_EQ(WGPUCreateReadyPipelineStatus::WGPUCreateReadyPipelineStatus_Error, status); + EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Error, status); - CreateReadyPipelineTask* task = static_cast<CreateReadyPipelineTask*>(userdata); + CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); task->computePipeline = wgpu::ComputePipeline::Acquire(returnPipeline); task->isCompleted = true; task->message = message; @@ -133,8 +133,8 @@ ASSERT_EQ(nullptr, task.computePipeline.Get()); } -// Verify the basic use of CreateReadyRenderPipeline() works on all backends. -TEST_P(CreateReadyPipelineTest, BasicUseOfCreateReadyRenderPipeline) { +// Verify the basic use of CreateRenderPipelineAsync() works on all backends. +TEST_P(CreatePipelineAsyncTest, BasicUseOfCreateRenderPipelineAsync) { constexpr wgpu::TextureFormat kRenderAttachmentFormat = wgpu::TextureFormat::RGBA8Unorm; utils::ComboRenderPipelineDescriptor renderPipelineDescriptor(device); @@ -153,13 +153,13 @@ renderPipelineDescriptor.cColorStates[0].format = kRenderAttachmentFormat; renderPipelineDescriptor.primitiveTopology = wgpu::PrimitiveTopology::PointList; - device.CreateReadyRenderPipeline( + device.CreateRenderPipelineAsync( &renderPipelineDescriptor, - [](WGPUCreateReadyPipelineStatus status, WGPURenderPipeline returnPipeline, + [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline returnPipeline, const char* message, void* userdata) { - EXPECT_EQ(WGPUCreateReadyPipelineStatus::WGPUCreateReadyPipelineStatus_Success, status); + EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Success, status); - CreateReadyPipelineTask* task = static_cast<CreateReadyPipelineTask*>(userdata); + CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); task->renderPipeline = wgpu::RenderPipeline::Acquire(returnPipeline); task->isCompleted = true; task->message = message; @@ -198,11 +198,11 @@ EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), outputTexture, 0, 0); } -// Verify CreateReadyRenderPipeline() works as expected when there is any error that happens during +// Verify CreateRenderPipelineAsync() works as expected when there is any error that happens during // the creation of the render pipeline. The SPEC requires that during the call of -// CreateReadyRenderPipeline() any error won't be forwarded to the error scope / unhandled error +// CreateRenderPipelineAsync() any error won't be forwarded to the error scope / unhandled error // callback. -TEST_P(CreateReadyPipelineTest, CreateRenderPipelineFailed) { +TEST_P(CreatePipelineAsyncTest, CreateRenderPipelineFailed) { DAWN_SKIP_TEST_IF(HasToggleEnabled("skip_validation")); constexpr wgpu::TextureFormat kRenderAttachmentFormat = wgpu::TextureFormat::Depth32Float; @@ -223,13 +223,13 @@ renderPipelineDescriptor.cColorStates[0].format = kRenderAttachmentFormat; renderPipelineDescriptor.primitiveTopology = wgpu::PrimitiveTopology::PointList; - device.CreateReadyRenderPipeline( + device.CreateRenderPipelineAsync( &renderPipelineDescriptor, - [](WGPUCreateReadyPipelineStatus status, WGPURenderPipeline returnPipeline, + [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline returnPipeline, const char* message, void* userdata) { - EXPECT_EQ(WGPUCreateReadyPipelineStatus::WGPUCreateReadyPipelineStatus_Error, status); + EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Error, status); - CreateReadyPipelineTask* task = static_cast<CreateReadyPipelineTask*>(userdata); + CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); task->renderPipeline = wgpu::RenderPipeline::Acquire(returnPipeline); task->isCompleted = true; task->message = message; @@ -245,22 +245,22 @@ } // Verify there is no error when the device is released before the callback of -// CreateReadyComputePipeline() is called. -TEST_P(CreateReadyPipelineTest, ReleaseDeviceBeforeCallbackOfCreateReadyComputePipeline) { +// CreateComputePipelineAsync() is called. +TEST_P(CreatePipelineAsyncTest, ReleaseDeviceBeforeCallbackOfCreateComputePipelineAsync) { wgpu::ComputePipelineDescriptor csDesc; csDesc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, R"( [[stage(compute)]] fn main() -> void { })"); csDesc.computeStage.entryPoint = "main"; - device.CreateReadyComputePipeline( + device.CreateComputePipelineAsync( &csDesc, - [](WGPUCreateReadyPipelineStatus status, WGPUComputePipeline returnPipeline, + [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline returnPipeline, const char* message, void* userdata) { - EXPECT_EQ(WGPUCreateReadyPipelineStatus::WGPUCreateReadyPipelineStatus_DeviceDestroyed, + EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_DeviceDestroyed, status); - CreateReadyPipelineTask* task = static_cast<CreateReadyPipelineTask*>(userdata); + CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); task->computePipeline = wgpu::ComputePipeline::Acquire(returnPipeline); task->isCompleted = true; task->message = message; @@ -269,8 +269,8 @@ } // Verify there is no error when the device is released before the callback of -// CreateReadyRenderPipeline() is called. -TEST_P(CreateReadyPipelineTest, ReleaseDeviceBeforeCallbackOfCreateReadyRenderPipeline) { +// CreateRenderPipelineAsync() is called. +TEST_P(CreatePipelineAsyncTest, ReleaseDeviceBeforeCallbackOfCreateRenderPipelineAsync) { utils::ComboRenderPipelineDescriptor renderPipelineDescriptor(device); wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( [[builtin(position)]] var<out> Position : vec4<f32>; @@ -287,14 +287,14 @@ renderPipelineDescriptor.cColorStates[0].format = wgpu::TextureFormat::RGBA8Unorm; renderPipelineDescriptor.primitiveTopology = wgpu::PrimitiveTopology::PointList; - device.CreateReadyRenderPipeline( + device.CreateRenderPipelineAsync( &renderPipelineDescriptor, - [](WGPUCreateReadyPipelineStatus status, WGPURenderPipeline returnPipeline, + [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline returnPipeline, const char* message, void* userdata) { - EXPECT_EQ(WGPUCreateReadyPipelineStatus::WGPUCreateReadyPipelineStatus_DeviceDestroyed, + EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_DeviceDestroyed, status); - CreateReadyPipelineTask* task = static_cast<CreateReadyPipelineTask*>(userdata); + CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); task->renderPipeline = wgpu::RenderPipeline::Acquire(returnPipeline); task->isCompleted = true; task->message = message; @@ -302,7 +302,7 @@ &task); } -DAWN_INSTANTIATE_TEST(CreateReadyPipelineTest, +DAWN_INSTANTIATE_TEST(CreatePipelineAsyncTest, D3D12Backend(), MetalBackend(), OpenGLBackend(),
diff --git a/src/tests/unittests/WorkerThreadTests.cpp b/src/tests/unittests/WorkerThreadTests.cpp index 8faee5d..996d7e1 100644 --- a/src/tests/unittests/WorkerThreadTests.cpp +++ b/src/tests/unittests/WorkerThreadTests.cpp
@@ -149,7 +149,7 @@ class WorkerThreadTest : public testing::Test {}; -// Emulate the basic usage of worker thread pool in CreateReady*Pipeline(). +// Emulate the basic usage of worker thread pool in Create*PipelineAsync(). TEST_F(WorkerThreadTest, Basic) { dawn_platform::Platform platform; std::unique_ptr<dawn_platform::WorkerTaskPool> pool = platform.CreateWorkerTaskPool();
diff --git a/src/tests/unittests/validation/MultipleDeviceTests.cpp b/src/tests/unittests/validation/MultipleDeviceTests.cpp index 1d1dee2..0f940b0 100644 --- a/src/tests/unittests/validation/MultipleDeviceTests.cpp +++ b/src/tests/unittests/validation/MultipleDeviceTests.cpp
@@ -28,9 +28,9 @@ ASSERT_DEVICE_ERROR(device.GetQueue().Submit(1, &commandBuffer)); } -// Test that CreateReadyPipeline fails creation with an Error status if it uses +// Test that CreatePipelineAsync fails creation with an Error status if it uses // objects from a different device. -TEST_F(MultipleDeviceTest, ValidatesSameDeviceCreateReadyPipeline) { +TEST_F(MultipleDeviceTest, ValidatesSameDeviceCreatePipelineAsync) { wgpu::ShaderModuleWGSLDescriptor wgslDesc = {}; wgslDesc.source = R"( [[stage(compute)]] fn main() -> void { @@ -40,7 +40,7 @@ wgpu::ShaderModuleDescriptor shaderModuleDesc = {}; shaderModuleDesc.nextInChain = &wgslDesc; - // Base case: CreateReadyComputePipeline succeeds. + // Base case: CreateComputePipelineAsync succeeds. { wgpu::ShaderModule shaderModule = device.CreateShaderModule(&shaderModuleDesc); @@ -48,18 +48,18 @@ pipelineDesc.computeStage.module = shaderModule; pipelineDesc.computeStage.entryPoint = "main"; - StrictMock<MockCallback<WGPUCreateReadyComputePipelineCallback>> creationCallback; + StrictMock<MockCallback<WGPUCreateComputePipelineAsyncCallback>> creationCallback; EXPECT_CALL(creationCallback, - Call(WGPUCreateReadyPipelineStatus_Success, NotNull(), _, this)) + Call(WGPUCreatePipelineAsyncStatus_Success, NotNull(), _, this)) .WillOnce(WithArg<1>(Invoke( [](WGPUComputePipeline pipeline) { wgpu::ComputePipeline::Acquire(pipeline); }))); - device.CreateReadyComputePipeline(&pipelineDesc, creationCallback.Callback(), + device.CreateComputePipelineAsync(&pipelineDesc, creationCallback.Callback(), creationCallback.MakeUserdata(this)); WaitForAllOperations(device); } - // CreateReadyComputePipeline errors if the shader module is created on a different device. + // CreateComputePipelineAsync errors if the shader module is created on a different device. { wgpu::Device device2 = RegisterDevice(CreateTestDevice()); wgpu::ShaderModule shaderModule = device2.CreateShaderModule(&shaderModuleDesc); @@ -68,11 +68,11 @@ pipelineDesc.computeStage.module = shaderModule; pipelineDesc.computeStage.entryPoint = "main"; - StrictMock<MockCallback<WGPUCreateReadyComputePipelineCallback>> creationCallback; + StrictMock<MockCallback<WGPUCreateComputePipelineAsyncCallback>> creationCallback; EXPECT_CALL(creationCallback, - Call(WGPUCreateReadyPipelineStatus_Error, nullptr, _, this + 1)) + Call(WGPUCreatePipelineAsyncStatus_Error, nullptr, _, this + 1)) .Times(1); - device.CreateReadyComputePipeline(&pipelineDesc, creationCallback.Callback(), + device.CreateComputePipelineAsync(&pipelineDesc, creationCallback.Callback(), creationCallback.MakeUserdata(this + 1)); WaitForAllOperations(device);
diff --git a/src/tests/unittests/wire/WireCreateReadyPipelineTests.cpp b/src/tests/unittests/wire/WireCreatePipelineAsyncTests.cpp similarity index 61% rename from src/tests/unittests/wire/WireCreateReadyPipelineTests.cpp rename to src/tests/unittests/wire/WireCreatePipelineAsyncTests.cpp index 2e7ae0f..72cdc94 100644 --- a/src/tests/unittests/wire/WireCreateReadyPipelineTests.cpp +++ b/src/tests/unittests/wire/WireCreatePipelineAsyncTests.cpp
@@ -22,78 +22,78 @@ namespace { // Mock class to add expectations on the wire calling callbacks - class MockCreateReadyComputePipelineCallback { + class MockCreateComputePipelineAsyncCallback { public: MOCK_METHOD(void, Call, - (WGPUCreateReadyPipelineStatus status, + (WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline, const char* message, void* userdata)); }; - std::unique_ptr<StrictMock<MockCreateReadyComputePipelineCallback>> - mockCreateReadyComputePipelineCallback; - void ToMockCreateReadyComputePipelineCallback(WGPUCreateReadyPipelineStatus status, + std::unique_ptr<StrictMock<MockCreateComputePipelineAsyncCallback>> + mockCreateComputePipelineAsyncCallback; + void ToMockCreateComputePipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline, const char* message, void* userdata) { - mockCreateReadyComputePipelineCallback->Call(status, pipeline, message, userdata); + mockCreateComputePipelineAsyncCallback->Call(status, pipeline, message, userdata); } - class MockCreateReadyRenderPipelineCallback { + class MockCreateRenderPipelineAsyncCallback { public: MOCK_METHOD(void, Call, - (WGPUCreateReadyPipelineStatus status, + (WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline, const char* message, void* userdata)); }; - std::unique_ptr<StrictMock<MockCreateReadyRenderPipelineCallback>> - mockCreateReadyRenderPipelineCallback; - void ToMockCreateReadyRenderPipelineCallback(WGPUCreateReadyPipelineStatus status, + std::unique_ptr<StrictMock<MockCreateRenderPipelineAsyncCallback>> + mockCreateRenderPipelineAsyncCallback; + void ToMockCreateRenderPipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline, const char* message, void* userdata) { - mockCreateReadyRenderPipelineCallback->Call(status, pipeline, message, userdata); + mockCreateRenderPipelineAsyncCallback->Call(status, pipeline, message, userdata); } } // anonymous namespace -class WireCreateReadyPipelineTest : public WireTest { +class WireCreatePipelineAsyncTest : public WireTest { public: void SetUp() override { WireTest::SetUp(); - mockCreateReadyComputePipelineCallback = - std::make_unique<StrictMock<MockCreateReadyComputePipelineCallback>>(); - mockCreateReadyRenderPipelineCallback = - std::make_unique<StrictMock<MockCreateReadyRenderPipelineCallback>>(); + mockCreateComputePipelineAsyncCallback = + std::make_unique<StrictMock<MockCreateComputePipelineAsyncCallback>>(); + mockCreateRenderPipelineAsyncCallback = + std::make_unique<StrictMock<MockCreateRenderPipelineAsyncCallback>>(); } void TearDown() override { WireTest::TearDown(); // Delete mock so that expectations are checked - mockCreateReadyComputePipelineCallback = nullptr; - mockCreateReadyRenderPipelineCallback = nullptr; + mockCreateComputePipelineAsyncCallback = nullptr; + mockCreateRenderPipelineAsyncCallback = nullptr; } void FlushClient() { WireTest::FlushClient(); - Mock::VerifyAndClearExpectations(&mockCreateReadyComputePipelineCallback); + Mock::VerifyAndClearExpectations(&mockCreateComputePipelineAsyncCallback); } void FlushServer() { WireTest::FlushServer(); - Mock::VerifyAndClearExpectations(&mockCreateReadyComputePipelineCallback); + Mock::VerifyAndClearExpectations(&mockCreateComputePipelineAsyncCallback); } }; -// Test when creating a compute pipeline with CreateReadyComputePipeline() successfully. -TEST_F(WireCreateReadyPipelineTest, CreateReadyComputePipelineSuccess) { +// Test when creating a compute pipeline with CreateComputePipelineAsync() successfully. +TEST_F(WireCreatePipelineAsyncTest, CreateComputePipelineAsyncSuccess) { WGPUShaderModuleDescriptor csDescriptor{}; WGPUShaderModule csModule = wgpuDeviceCreateShaderModule(device, &csDescriptor); WGPUShaderModule apiCsModule = api.GetNewShaderModule(); @@ -103,26 +103,26 @@ descriptor.computeStage.module = csModule; descriptor.computeStage.entryPoint = "main"; - wgpuDeviceCreateReadyComputePipeline(device, &descriptor, - ToMockCreateReadyComputePipelineCallback, this); + wgpuDeviceCreateComputePipelineAsync(device, &descriptor, + ToMockCreateComputePipelineAsyncCallback, this); - EXPECT_CALL(api, OnDeviceCreateReadyComputePipeline(apiDevice, _, _, _)) + EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallDeviceCreateReadyComputePipelineCallback( - apiDevice, WGPUCreateReadyPipelineStatus_Success, nullptr, ""); + api.CallDeviceCreateComputePipelineAsyncCallback( + apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, ""); })); FlushClient(); - EXPECT_CALL(*mockCreateReadyComputePipelineCallback, - Call(WGPUCreateReadyPipelineStatus_Success, _, StrEq(""), this)) + EXPECT_CALL(*mockCreateComputePipelineAsyncCallback, + Call(WGPUCreatePipelineAsyncStatus_Success, _, StrEq(""), this)) .Times(1); FlushServer(); } -// Test when creating a compute pipeline with CreateReadyComputePipeline() results in an error. -TEST_F(WireCreateReadyPipelineTest, CreateReadyComputePipelineError) { +// Test when creating a compute pipeline with CreateComputePipelineAsync() results in an error. +TEST_F(WireCreatePipelineAsyncTest, CreateComputePipelineAsyncError) { WGPUShaderModuleDescriptor csDescriptor{}; WGPUShaderModule csModule = wgpuDeviceCreateShaderModule(device, &csDescriptor); WGPUShaderModule apiCsModule = api.GetNewShaderModule(); @@ -132,26 +132,26 @@ descriptor.computeStage.module = csModule; descriptor.computeStage.entryPoint = "main"; - wgpuDeviceCreateReadyComputePipeline(device, &descriptor, - ToMockCreateReadyComputePipelineCallback, this); + wgpuDeviceCreateComputePipelineAsync(device, &descriptor, + ToMockCreateComputePipelineAsyncCallback, this); - EXPECT_CALL(api, OnDeviceCreateReadyComputePipeline(apiDevice, _, _, _)) + EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallDeviceCreateReadyComputePipelineCallback( - apiDevice, WGPUCreateReadyPipelineStatus_Error, nullptr, "Some error message"); + api.CallDeviceCreateComputePipelineAsyncCallback( + apiDevice, WGPUCreatePipelineAsyncStatus_Error, nullptr, "Some error message"); })); FlushClient(); - EXPECT_CALL(*mockCreateReadyComputePipelineCallback, - Call(WGPUCreateReadyPipelineStatus_Error, _, StrEq("Some error message"), this)) + EXPECT_CALL(*mockCreateComputePipelineAsyncCallback, + Call(WGPUCreatePipelineAsyncStatus_Error, _, StrEq("Some error message"), this)) .Times(1); FlushServer(); } -// Test when creating a render pipeline with CreateReadyRenderPipeline() successfully. -TEST_F(WireCreateReadyPipelineTest, CreateReadyRenderPipelineSuccess) { +// Test when creating a render pipeline with CreateRenderPipelineAsync() successfully. +TEST_F(WireCreatePipelineAsyncTest, CreateRenderPipelineAsyncSuccess) { WGPUShaderModuleDescriptor vertexDescriptor = {}; WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(device, &vertexDescriptor); WGPUShaderModule apiVsModule = api.GetNewShaderModule(); @@ -166,25 +166,25 @@ fragmentStage.entryPoint = "main"; pipelineDescriptor.fragmentStage = &fragmentStage; - wgpuDeviceCreateReadyRenderPipeline(device, &pipelineDescriptor, - ToMockCreateReadyRenderPipelineCallback, this); - EXPECT_CALL(api, OnDeviceCreateReadyRenderPipeline(apiDevice, _, _, _)) + wgpuDeviceCreateRenderPipelineAsync(device, &pipelineDescriptor, + ToMockCreateRenderPipelineAsyncCallback, this); + EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallDeviceCreateReadyRenderPipelineCallback( - apiDevice, WGPUCreateReadyPipelineStatus_Success, nullptr, ""); + api.CallDeviceCreateRenderPipelineAsyncCallback( + apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, ""); })); FlushClient(); - EXPECT_CALL(*mockCreateReadyRenderPipelineCallback, - Call(WGPUCreateReadyPipelineStatus_Success, _, StrEq(""), this)) + EXPECT_CALL(*mockCreateRenderPipelineAsyncCallback, + Call(WGPUCreatePipelineAsyncStatus_Success, _, StrEq(""), this)) .Times(1); FlushServer(); } -// Test when creating a render pipeline with CreateReadyRenderPipeline() results in an error. -TEST_F(WireCreateReadyPipelineTest, CreateReadyRenderPipelineError) { +// Test when creating a render pipeline with CreateRenderPipelineAsync() results in an error. +TEST_F(WireCreatePipelineAsyncTest, CreateRenderPipelineAsyncError) { WGPUShaderModuleDescriptor vertexDescriptor = {}; WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(device, &vertexDescriptor); WGPUShaderModule apiVsModule = api.GetNewShaderModule(); @@ -199,18 +199,18 @@ fragmentStage.entryPoint = "main"; pipelineDescriptor.fragmentStage = &fragmentStage; - wgpuDeviceCreateReadyRenderPipeline(device, &pipelineDescriptor, - ToMockCreateReadyRenderPipelineCallback, this); - EXPECT_CALL(api, OnDeviceCreateReadyRenderPipeline(apiDevice, _, _, _)) + wgpuDeviceCreateRenderPipelineAsync(device, &pipelineDescriptor, + ToMockCreateRenderPipelineAsyncCallback, this); + EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallDeviceCreateReadyRenderPipelineCallback( - apiDevice, WGPUCreateReadyPipelineStatus_Error, nullptr, "Some error message"); + api.CallDeviceCreateRenderPipelineAsyncCallback( + apiDevice, WGPUCreatePipelineAsyncStatus_Error, nullptr, "Some error message"); })); FlushClient(); - EXPECT_CALL(*mockCreateReadyRenderPipelineCallback, - Call(WGPUCreateReadyPipelineStatus_Error, _, StrEq("Some error message"), this)) + EXPECT_CALL(*mockCreateRenderPipelineAsyncCallback, + Call(WGPUCreatePipelineAsyncStatus_Error, _, StrEq("Some error message"), this)) .Times(1); FlushServer(); @@ -218,7 +218,7 @@ // Test that registering a callback then wire disconnect calls the callback with // DeviceLost. -TEST_F(WireCreateReadyPipelineTest, CreateReadyRenderPipelineThenDisconnect) { +TEST_F(WireCreatePipelineAsyncTest, CreateRenderPipelineAsyncThenDisconnect) { WGPUShaderModuleDescriptor vertexDescriptor = {}; WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(device, &vertexDescriptor); WGPUShaderModule apiVsModule = api.GetNewShaderModule(); @@ -233,25 +233,25 @@ pipelineDescriptor.vertexStage.entryPoint = "main"; pipelineDescriptor.fragmentStage = &fragmentStage; - wgpuDeviceCreateReadyRenderPipeline(device, &pipelineDescriptor, - ToMockCreateReadyRenderPipelineCallback, this); - EXPECT_CALL(api, OnDeviceCreateReadyRenderPipeline(apiDevice, _, _, _)) + wgpuDeviceCreateRenderPipelineAsync(device, &pipelineDescriptor, + ToMockCreateRenderPipelineAsyncCallback, this); + EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallDeviceCreateReadyRenderPipelineCallback( - apiDevice, WGPUCreateReadyPipelineStatus_Success, nullptr, ""); + api.CallDeviceCreateRenderPipelineAsyncCallback( + apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, ""); })); FlushClient(); - EXPECT_CALL(*mockCreateReadyRenderPipelineCallback, - Call(WGPUCreateReadyPipelineStatus_DeviceLost, _, _, this)) + EXPECT_CALL(*mockCreateRenderPipelineAsyncCallback, + Call(WGPUCreatePipelineAsyncStatus_DeviceLost, _, _, this)) .Times(1); GetWireClient()->Disconnect(); } // Test that registering a callback then wire disconnect calls the callback with // DeviceLost. -TEST_F(WireCreateReadyPipelineTest, CreateReadyComputePipelineThenDisconnect) { +TEST_F(WireCreatePipelineAsyncTest, CreateComputePipelineAsyncThenDisconnect) { WGPUShaderModuleDescriptor csDescriptor{}; WGPUShaderModule csModule = wgpuDeviceCreateShaderModule(device, &csDescriptor); WGPUShaderModule apiCsModule = api.GetNewShaderModule(); @@ -261,25 +261,25 @@ descriptor.computeStage.module = csModule; descriptor.computeStage.entryPoint = "main"; - wgpuDeviceCreateReadyComputePipeline(device, &descriptor, - ToMockCreateReadyComputePipelineCallback, this); - EXPECT_CALL(api, OnDeviceCreateReadyComputePipeline(apiDevice, _, _, _)) + wgpuDeviceCreateComputePipelineAsync(device, &descriptor, + ToMockCreateComputePipelineAsyncCallback, this); + EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _, _)) .WillOnce(InvokeWithoutArgs([&]() { - api.CallDeviceCreateReadyComputePipelineCallback( - apiDevice, WGPUCreateReadyPipelineStatus_Success, nullptr, ""); + api.CallDeviceCreateComputePipelineAsyncCallback( + apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, ""); })); FlushClient(); - EXPECT_CALL(*mockCreateReadyComputePipelineCallback, - Call(WGPUCreateReadyPipelineStatus_DeviceLost, _, _, this)) + EXPECT_CALL(*mockCreateComputePipelineAsyncCallback, + Call(WGPUCreatePipelineAsyncStatus_DeviceLost, _, _, this)) .Times(1); GetWireClient()->Disconnect(); } // Test that registering a callback after wire disconnect calls the callback with // DeviceLost. -TEST_F(WireCreateReadyPipelineTest, CreateReadyRenderPipelineAfterDisconnect) { +TEST_F(WireCreatePipelineAsyncTest, CreateRenderPipelineAsyncAfterDisconnect) { WGPUShaderModuleDescriptor vertexDescriptor = {}; WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(device, &vertexDescriptor); WGPUShaderModule apiVsModule = api.GetNewShaderModule(); @@ -298,16 +298,16 @@ GetWireClient()->Disconnect(); - EXPECT_CALL(*mockCreateReadyRenderPipelineCallback, - Call(WGPUCreateReadyPipelineStatus_DeviceLost, nullptr, _, this)) + EXPECT_CALL(*mockCreateRenderPipelineAsyncCallback, + Call(WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr, _, this)) .Times(1); - wgpuDeviceCreateReadyRenderPipeline(device, &pipelineDescriptor, - ToMockCreateReadyRenderPipelineCallback, this); + wgpuDeviceCreateRenderPipelineAsync(device, &pipelineDescriptor, + ToMockCreateRenderPipelineAsyncCallback, this); } // Test that registering a callback after wire disconnect calls the callback with // DeviceLost. -TEST_F(WireCreateReadyPipelineTest, CreateReadyComputePipelineAfterDisconnect) { +TEST_F(WireCreatePipelineAsyncTest, CreateComputePipelineAsyncAfterDisconnect) { WGPUShaderModuleDescriptor csDescriptor{}; WGPUShaderModule csModule = wgpuDeviceCreateShaderModule(device, &csDescriptor); WGPUShaderModule apiCsModule = api.GetNewShaderModule(); @@ -321,15 +321,15 @@ GetWireClient()->Disconnect(); - EXPECT_CALL(*mockCreateReadyComputePipelineCallback, - Call(WGPUCreateReadyPipelineStatus_DeviceLost, nullptr, _, this)) + EXPECT_CALL(*mockCreateComputePipelineAsyncCallback, + Call(WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr, _, this)) .Times(1); - wgpuDeviceCreateReadyComputePipeline(device, &descriptor, - ToMockCreateReadyComputePipelineCallback, this); + wgpuDeviceCreateComputePipelineAsync(device, &descriptor, + ToMockCreateComputePipelineAsyncCallback, this); } -TEST_F(WireCreateReadyPipelineTest, DeviceDeletedBeforeCallback) { +TEST_F(WireCreatePipelineAsyncTest, DeviceDeletedBeforeCallback) { WGPUShaderModuleDescriptor vertexDescriptor = {}; WGPUShaderModule module = wgpuDeviceCreateShaderModule(device, &vertexDescriptor); WGPUShaderModule apiModule = api.GetNewShaderModule(); @@ -344,14 +344,14 @@ fragmentStage.entryPoint = "main"; pipelineDescriptor.fragmentStage = &fragmentStage; - wgpuDeviceCreateReadyRenderPipeline(device, &pipelineDescriptor, - ToMockCreateReadyRenderPipelineCallback, this); + wgpuDeviceCreateRenderPipelineAsync(device, &pipelineDescriptor, + ToMockCreateRenderPipelineAsyncCallback, this); - EXPECT_CALL(api, OnDeviceCreateReadyRenderPipeline(apiDevice, _, _, _)); + EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _, _)); FlushClient(); - EXPECT_CALL(*mockCreateReadyRenderPipelineCallback, - Call(WGPUCreateReadyPipelineStatus_DeviceDestroyed, nullptr, _, this)) + EXPECT_CALL(*mockCreateRenderPipelineAsyncCallback, + Call(WGPUCreatePipelineAsyncStatus_DeviceDestroyed, nullptr, _, this)) .Times(1); wgpuDeviceRelease(device);