[WebGPU] Add the entry point of CreateReadyRenderPipeline

BUG=dawn:529

Change-Id: I9cae2840f7e653372d9434a2d8a9ea386ede988b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2574062
Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Cr-Commit-Position: refs/heads/master@{#834653}

third_party/blink/renderer/modules/webgpu/gpu_device.cc

@@ -149,6 +149,33 @@ void GPUDevice::OnDeviceLostError(const char* message) {
   }
 }
 
+void GPUDevice::OnCreateReadyRenderPipelineCallback(
+    ScriptPromiseResolver* resolver,
+    WGPUCreateReadyPipelineStatus status,
+    WGPURenderPipeline render_pipeline,
+    const char* message) {
+  switch (status) {
+    case WGPUCreateReadyPipelineStatus_Success: {
+      resolver->Resolve(
+          MakeGarbageCollected<GPURenderPipeline>(this, render_pipeline));
+      break;
+    }
+
+    case WGPUCreateReadyPipelineStatus_Error:
+    case WGPUCreateReadyPipelineStatus_DeviceLost:
+    case WGPUCreateReadyPipelineStatus_DeviceDestroyed:
+    case WGPUCreateReadyPipelineStatus_Unknown: {
+      resolver->Reject(MakeGarbageCollected<DOMException>(
+          DOMExceptionCode::kOperationError, message));
+      break;
+    }
+
+    default: {
+      NOTREACHED();
+    }
+  }
+}
+
 void GPUDevice::OnCreateReadyComputePipelineCallback(
     ScriptPromiseResolver* resolver,
     WGPUCreateReadyPipelineStatus status,
@@ -239,6 +266,36 @@ GPUComputePipeline* GPUDevice::createComputePipeline(
   return GPUComputePipeline::Create(this, descriptor);
 }
 
+ScriptPromise GPUDevice::createReadyRenderPipeline(
+    ScriptState* script_state,
+    const GPURenderPipelineDescriptor* descriptor) {
+  auto* resolver = MakeGarbageCollected<ScriptPromiseResolver>(script_state);
+  ScriptPromise promise = resolver->Promise();
+
+  OwnedRenderPipelineDescriptor dawn_desc_info;
+  v8::Isolate* isolate = script_state->GetIsolate();
+  ExceptionState exception_state(isolate, ExceptionState::kConstructionContext,
+                                 "GPUVertexStateDescriptor");
+  ConvertToDawnType(isolate, descriptor, &dawn_desc_info, exception_state);
+  if (exception_state.HadException()) {
+    resolver->Reject(MakeGarbageCollected<DOMException>(
+        DOMExceptionCode::kOperationError,
+        "Error in parsing GPURenderPipelineDescriptor"));
+  } else {
+    auto* callback =
+        BindDawnCallback(&GPUDevice::OnCreateReadyRenderPipelineCallback,
+                         WrapPersistent(this), WrapPersistent(resolver));
+    GetProcs().deviceCreateReadyRenderPipeline(
+        GetHandle(), &dawn_desc_info.dawn_desc, callback->UnboundCallback(),
+        callback->AsUserdata());
+  }
+
+  // WebGPU guarantees that promises are resolved in finite time so we need to
+  // ensure commands are flushed.
+  EnsureFlush();
+  return promise;
+}
+
 ScriptPromise GPUDevice::createReadyComputePipeline(
     ScriptState* script_state,
     const GPUComputePipelineDescriptor* descriptor) {

third_party/blink/renderer/modules/webgpu/gpu_device.h

@@ -92,6 +92,9 @@ class GPUDevice final : public EventTargetWithInlineData,
       const GPURenderPipelineDescriptor* descriptor);
   GPUComputePipeline* createComputePipeline(
       const GPUComputePipelineDescriptor* descriptor);
+  ScriptPromise createReadyRenderPipeline(
+      ScriptState* script_state,
+      const GPURenderPipelineDescriptor* descriptor);
   ScriptPromise createReadyComputePipeline(
       ScriptState* script_state,
       const GPUComputePipelineDescriptor* descriptor);
@@ -126,6 +129,10 @@ class GPUDevice final : public EventTargetWithInlineData,
                                WGPUErrorType type,
                                const char* message);
 
+  void OnCreateReadyRenderPipelineCallback(ScriptPromiseResolver* resolver,
+                                           WGPUCreateReadyPipelineStatus status,
+                                           WGPURenderPipeline render_pipeline,
+                                           const char* message);
   void OnCreateReadyComputePipelineCallback(
       ScriptPromiseResolver* resolver,
       WGPUCreateReadyPipelineStatus status,

third_party/blink/renderer/modules/webgpu/gpu_device.idl

@@ -25,6 +25,7 @@
     [CallWith=ScriptState] GPURenderPipeline createRenderPipeline(GPURenderPipelineDescriptor descriptor);
     GPUComputePipeline createComputePipeline(GPUComputePipelineDescriptor descriptor);
 
+    [CallWith=ScriptState] Promise<GPURenderPipeline?> createReadyRenderPipeline(GPURenderPipelineDescriptor descriptor);
     [CallWith=ScriptState] Promise<GPUComputePipeline?> createReadyComputePipeline(GPUComputePipelineDescriptor descriptor);
 
     GPUCommandEncoder createCommandEncoder(optional GPUCommandEncoderDescriptor descriptor = {});

third_party/blink/renderer/modules/webgpu/gpu_render_pipeline.h

@@ -5,14 +5,47 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_WEBGPU_GPU_RENDER_PIPELINE_H_
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_WEBGPU_GPU_RENDER_PIPELINE_H_
 
+#include "third_party/blink/renderer/modules/webgpu/dawn_conversions.h"
 #include "third_party/blink/renderer/modules/webgpu/dawn_object.h"
 
 namespace blink {
 
 class GPUBindGroupLayout;
 class GPURenderPipelineDescriptor;
+class ExceptionState;
 class ScriptState;
 
+struct OwnedRenderPipelineDescriptor {
+ public:
+  OwnedRenderPipelineDescriptor() : dawn_desc({}) {}
+
+  //  This struct should be non-copyable non-movable because it contains
+  //  self-referencing pointers that would be invalidated when moved / copied.
+  OwnedRenderPipelineDescriptor(const OwnedRenderPipelineDescriptor& desc) =
+      delete;
+  OwnedRenderPipelineDescriptor(OwnedRenderPipelineDescriptor&& desc) = delete;
+  OwnedRenderPipelineDescriptor& operator=(
+      const OwnedRenderPipelineDescriptor& desc) = delete;
+  OwnedRenderPipelineDescriptor& operator=(
+      OwnedRenderPipelineDescriptor&& desc) = delete;
+
+  WGPURenderPipelineDescriptor dawn_desc;
+  std::string label;
+  OwnedProgrammableStageDescriptor vertex_stage_info;
+  OwnedProgrammableStageDescriptor fragment_stage_info;
+  WGPUVertexStateDescriptor vertex_state;
+  Vector<WGPUVertexBufferLayoutDescriptor> vertex_buffer_layouts;
+  Vector<WGPUVertexAttributeDescriptor> vertex_attributes;
+  WGPURasterizationStateDescriptor rasterization_state;
+  WGPUDepthStencilStateDescriptor depth_stencil_state;
+  std::unique_ptr<WGPUColorStateDescriptor[]> color_states;
+};
+
+void ConvertToDawnType(v8::Isolate* isolate,
+                       const GPURenderPipelineDescriptor* webgpu_desc,
+                       OwnedRenderPipelineDescriptor* dawn_desc_info,
+                       ExceptionState& exception_state);
+
 class GPURenderPipeline : public DawnObject<WGPURenderPipeline> {
   DEFINE_WRAPPERTYPEINFO();