Add the entry point of CreateReadyRenderPipeline

BUG=dawn:529
TEST=dawn_end2end_tests

Change-Id: I42ac0edc77e5b6119eb374da72698fca14596f7b
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30540
Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
Reviewed-by: Austin Eng <enga@chromium.org>

src/dawn_native/CreateReadyPipelineTracker.cpp

@@ -18,39 +18,72 @@
 
 namespace dawn_native {
 
+    CreateReadyPipelineTaskBase::CreateReadyPipelineTaskBase(void* userdata) : mUserData(userdata) {
+    }
+
+    CreateReadyPipelineTaskBase::~CreateReadyPipelineTaskBase() {
+    }
+
     CreateReadyComputePipelineTask::CreateReadyComputePipelineTask(
         ComputePipelineBase* pipeline,
         WGPUCreateReadyComputePipelineCallback callback,
         void* userdata)
-        : mPipeline(pipeline), mCallback(callback), mUserData(userdata) {
-    }
-
-    CreateReadyComputePipelineTask::~CreateReadyComputePipelineTask() {
+        : CreateReadyPipelineTaskBase(userdata),
+          mPipeline(pipeline),
+          mCreateReadyComputePipelineCallback(callback) {
     }
 
     void CreateReadyComputePipelineTask::Finish() {
-        mCallback(WGPUCreateReadyPipelineStatus_Success,
-                  reinterpret_cast<WGPUComputePipeline>(mPipeline), "", mUserData);
+        ASSERT(mPipeline != nullptr);
+        ASSERT(mCreateReadyComputePipelineCallback != nullptr);
+
+        mCreateReadyComputePipelineCallback(WGPUCreateReadyPipelineStatus_Success,
+                                            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() {
+        ASSERT(mPipeline != nullptr);
+        ASSERT(mCreateReadyRenderPipelineCallback != nullptr);
+
+        mCreateReadyRenderPipelineCallback(WGPUCreateReadyPipelineStatus_Success,
+                                           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(mCreateReadyComputePipelineTasksInFlight.Empty());
+        ASSERT(mCreateReadyPipelineTasksInFlight.Empty());
     }
 
-    void CreateReadyPipelineTracker::TrackTask(std::unique_ptr<CreateReadyComputePipelineTask> task,
+    void CreateReadyPipelineTracker::TrackTask(std::unique_ptr<CreateReadyPipelineTaskBase> task,
                                                ExecutionSerial serial) {
-        mCreateReadyComputePipelineTasksInFlight.Enqueue(std::move(task), serial);
+        mCreateReadyPipelineTasksInFlight.Enqueue(std::move(task), serial);
         mDevice->AddFutureSerial(serial);
     }
 
     void CreateReadyPipelineTracker::Tick(ExecutionSerial finishedSerial) {
-        for (auto& task : mCreateReadyComputePipelineTasksInFlight.IterateUpTo(finishedSerial)) {
+        for (auto& task : mCreateReadyPipelineTasksInFlight.IterateUpTo(finishedSerial)) {
             task->Finish();
         }
-        mCreateReadyComputePipelineTasksInFlight.ClearUpTo(finishedSerial);
+        mCreateReadyPipelineTasksInFlight.ClearUpTo(finishedSerial);
     }
 
 }  // namespace dawn_native

src/dawn_native/CreateReadyPipelineTracker.h

@@ -25,19 +25,41 @@ namespace dawn_native {
 
     class ComputePipelineBase;
     class DeviceBase;
+    class PipelineBase;
+    class RenderPipelineBase;
 
-    struct CreateReadyComputePipelineTask {
+    struct CreateReadyPipelineTaskBase {
+        CreateReadyPipelineTaskBase(void* userData);
+        virtual ~CreateReadyPipelineTaskBase();
+
+        virtual void Finish() = 0;
+
+      protected:
+        void* mUserData;
+    };
+
+    struct CreateReadyComputePipelineTask final : public CreateReadyPipelineTaskBase {
         CreateReadyComputePipelineTask(ComputePipelineBase* pipeline,
                                        WGPUCreateReadyComputePipelineCallback callback,
                                        void* userdata);
-        ~CreateReadyComputePipelineTask();
 
-        void Finish();
+        void Finish() final;
 
       private:
         ComputePipelineBase* mPipeline;
-        WGPUCreateReadyComputePipelineCallback mCallback;
-        void* mUserData;
+        WGPUCreateReadyComputePipelineCallback mCreateReadyComputePipelineCallback;
+    };
+
+    struct CreateReadyRenderPipelineTask final : public CreateReadyPipelineTaskBase {
+        CreateReadyRenderPipelineTask(RenderPipelineBase* pipeline,
+                                      WGPUCreateReadyRenderPipelineCallback callback,
+                                      void* userdata);
+
+        void Finish() final;
+
+      private:
+        RenderPipelineBase* mPipeline;
+        WGPUCreateReadyRenderPipelineCallback mCreateReadyRenderPipelineCallback;
     };
 
     class CreateReadyPipelineTracker {
@@ -45,14 +67,13 @@ namespace dawn_native {
         CreateReadyPipelineTracker(DeviceBase* device);
         ~CreateReadyPipelineTracker();
 
-        void TrackTask(std::unique_ptr<CreateReadyComputePipelineTask> task,
-                       ExecutionSerial serial);
+        void TrackTask(std::unique_ptr<CreateReadyPipelineTaskBase> task, ExecutionSerial serial);
         void Tick(ExecutionSerial finishedSerial);
 
       private:
         DeviceBase* mDevice;
-        SerialQueue<ExecutionSerial, std::unique_ptr<CreateReadyComputePipelineTask>>
-            mCreateReadyComputePipelineTasksInFlight;
+        SerialQueue<ExecutionSerial, std::unique_ptr<CreateReadyPipelineTaskBase>>
+            mCreateReadyPipelineTasksInFlight;
     };
 
 }  // namespace dawn_native

src/dawn_native/Device.cpp

@@ -674,6 +674,22 @@ namespace dawn_native {
 
         return result;
     }
+    void DeviceBase::CreateReadyRenderPipeline(const RenderPipelineDescriptor* descriptor,
+                                               WGPUCreateReadyRenderPipelineCallback 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(),
+                     userdata);
+            return;
+        }
+
+        std::unique_ptr<CreateReadyRenderPipelineTask> request =
+            std::make_unique<CreateReadyRenderPipelineTask>(result, callback, userdata);
+        mCreateReadyPipelineTracker->TrackTask(std::move(request), GetPendingCommandSerial());
+    }
     RenderBundleEncoder* DeviceBase::CreateRenderBundleEncoder(
         const RenderBundleEncoderDescriptor* descriptor) {
         RenderBundleEncoder* result = nullptr;

src/dawn_native/Device.h

@@ -149,6 +149,9 @@ namespace dawn_native {
         void CreateReadyComputePipeline(const ComputePipelineDescriptor* descriptor,
                                         WGPUCreateReadyComputePipelineCallback callback,
                                         void* userdata);
+        void CreateReadyRenderPipeline(const RenderPipelineDescriptor* descriptor,
+                                       WGPUCreateReadyRenderPipelineCallback callback,
+                                       void* userdata);
         RenderBundleEncoder* CreateRenderBundleEncoder(
             const RenderBundleEncoderDescriptor* descriptor);
         RenderPipelineBase* CreateRenderPipeline(const RenderPipelineDescriptor* descriptor);