[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.cc

@@ -14,7 +14,6 @@
 #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_vertex_attribute_descriptor.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_vertex_buffer_layout_descriptor.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_vertex_state_descriptor.h"
-#include "third_party/blink/renderer/modules/webgpu/dawn_conversions.h"
 #include "third_party/blink/renderer/modules/webgpu/gpu_bind_group_layout.h"
 #include "third_party/blink/renderer/modules/webgpu/gpu_device.h"
 #include "third_party/blink/renderer/modules/webgpu/gpu_pipeline_layout.h"
@@ -88,22 +87,24 @@ WGPUDepthStencilStateDescriptor AsDawnType(
   return dawn_desc;
 }
 
-using WGPUVertexStateInfo = std::tuple<WGPUVertexStateDescriptor,
-                                       Vector<WGPUVertexBufferLayoutDescriptor>,
-                                       Vector<WGPUVertexAttributeDescriptor>>;
-
-WGPUVertexStateInfo GPUVertexStateAsWGPUVertexState(
+void GPUVertexStateAsWGPUVertexState(
     v8::Isolate* isolate,
     const GPUVertexStateDescriptor* descriptor,
+    WGPUVertexStateDescriptor* dawn_desc,
+    Vector<WGPUVertexBufferLayoutDescriptor>* dawn_vertex_buffers,
+    Vector<WGPUVertexAttributeDescriptor>* dawn_vertex_attributes,
     ExceptionState& exception_state) {
-  WGPUVertexStateDescriptor dawn_desc = {};
-  dawn_desc.indexFormat =
+  DCHECK(isolate);
+  DCHECK(descriptor);
+  DCHECK(dawn_desc);
+  DCHECK(dawn_vertex_buffers);
+  DCHECK(dawn_vertex_attributes);
+
+  *dawn_desc = {};
+  dawn_desc->indexFormat =
       AsDawnEnum<WGPUIndexFormat>(descriptor->indexFormat());
-  dawn_desc.vertexBufferCount = 0;
-  dawn_desc.vertexBuffers = nullptr;
-
-  Vector<WGPUVertexBufferLayoutDescriptor> dawn_vertex_buffers;
-  Vector<WGPUVertexAttributeDescriptor> dawn_vertex_attributes;
+  dawn_desc->vertexBufferCount = 0;
+  dawn_desc->vertexBuffers = nullptr;
 
   if (descriptor->hasVertexBuffers()) {
     // TODO(crbug.com/951629): Use a sequence of nullable descriptors.
@@ -111,9 +112,7 @@ WGPUVertexStateInfo GPUVertexStateAsWGPUVertexState(
         descriptor->vertexBuffers().V8Value();
     if (!vertex_buffers_value->IsArray()) {
       exception_state.ThrowTypeError("vertexBuffers must be an array");
-
-      return std::make_tuple(dawn_desc, std::move(dawn_vertex_buffers),
-                             std::move(dawn_vertex_attributes));
+      return;
     }
 
     v8::Local<v8::Context> context = isolate->GetCurrentContext();
@@ -135,7 +134,7 @@ WGPUVertexStateInfo GPUVertexStateAsWGPUVertexState(
         dawn_vertex_buffer.stepMode = WGPUInputStepMode_Vertex;
         dawn_vertex_buffer.attributeCount = 0;
         dawn_vertex_buffer.attributes = nullptr;
-        dawn_vertex_buffers.push_back(dawn_vertex_buffer);
+        dawn_vertex_buffers->push_back(dawn_vertex_buffer);
         continue;
       }
 
@@ -143,8 +142,7 @@ WGPUVertexStateInfo GPUVertexStateAsWGPUVertexState(
           NativeValueTraits<GPUVertexBufferLayoutDescriptor>::NativeValue(
               isolate, value, exception_state);
       if (exception_state.HadException()) {
-        return std::make_tuple(dawn_desc, std::move(dawn_vertex_buffers),
-                               std::move(dawn_vertex_attributes));
+        return;
       }
 
       WGPUVertexBufferLayoutDescriptor dawn_vertex_buffer = {};
@@ -154,7 +152,7 @@ WGPUVertexStateInfo GPUVertexStateAsWGPUVertexState(
       dawn_vertex_buffer.attributeCount =
           static_cast<uint32_t>(vertex_buffer->attributes().size());
       dawn_vertex_buffer.attributes = nullptr;
-      dawn_vertex_buffers.push_back(dawn_vertex_buffer);
+      dawn_vertex_buffers->push_back(dawn_vertex_buffer);
 
       for (wtf_size_t j = 0; j < vertex_buffer->attributes().size(); ++j) {
         const GPUVertexAttributeDescriptor* attribute =
@@ -164,7 +162,7 @@ WGPUVertexStateInfo GPUVertexStateAsWGPUVertexState(
         dawn_vertex_attribute.offset = attribute->offset();
         dawn_vertex_attribute.format =
             AsDawnEnum<WGPUVertexFormat>(attribute->format());
-        dawn_vertex_attributes.push_back(dawn_vertex_attribute);
+        dawn_vertex_attributes->push_back(dawn_vertex_attribute);
       }
     }
 
@@ -172,21 +170,18 @@ WGPUVertexStateInfo GPUVertexStateAsWGPUVertexState(
     // after we stopped appending to the vector so the pointers aren't
     // invalidated.
     uint32_t attributeIndex = 0;
-    for (WGPUVertexBufferLayoutDescriptor& buffer : dawn_vertex_buffers) {
+    for (WGPUVertexBufferLayoutDescriptor& buffer : *dawn_vertex_buffers) {
       if (buffer.attributeCount == 0) {
         continue;
       }
-      buffer.attributes = &dawn_vertex_attributes[attributeIndex];
+      buffer.attributes = &(*dawn_vertex_attributes)[attributeIndex];
       attributeIndex += buffer.attributeCount;
     }
   }
 
-  dawn_desc.vertexBufferCount =
-      static_cast<uint32_t>(dawn_vertex_buffers.size());
-  dawn_desc.vertexBuffers = dawn_vertex_buffers.data();
-
-  return std::make_tuple(dawn_desc, std::move(dawn_vertex_buffers),
-                         std::move(dawn_vertex_attributes));
+  dawn_desc->vertexBufferCount =
+      static_cast<uint32_t>(dawn_vertex_buffers->size());
+  dawn_desc->vertexBuffers = dawn_vertex_buffers->data();
 }
 
 WGPURasterizationStateDescriptor AsDawnType(
@@ -206,79 +201,89 @@ WGPURasterizationStateDescriptor AsDawnType(
 
 }  // anonymous namespace
 
-// static
-GPURenderPipeline* GPURenderPipeline::Create(
-    ScriptState* script_state,
-    GPUDevice* device,
-    const GPURenderPipelineDescriptor* webgpu_desc) {
-  DCHECK(device);
+void ConvertToDawnType(v8::Isolate* isolate,
+                       const GPURenderPipelineDescriptor* webgpu_desc,
+                       OwnedRenderPipelineDescriptor* dawn_desc_info,
+                       ExceptionState& exception_state) {
+  DCHECK(isolate);
   DCHECK(webgpu_desc);
+  DCHECK(dawn_desc_info);
+
+  GPUVertexStateAsWGPUVertexState(
+      isolate, webgpu_desc->vertexState(), &dawn_desc_info->vertex_state,
+      &dawn_desc_info->vertex_buffer_layouts,
+      &dawn_desc_info->vertex_attributes, exception_state);
+  if (exception_state.HadException()) {
+    return;
+  }
+  dawn_desc_info->dawn_desc.vertexState = &dawn_desc_info->vertex_state;
 
-  std::string label;
-  WGPURenderPipelineDescriptor dawn_desc = {};
-  dawn_desc.nextInChain = nullptr;
   if (webgpu_desc->hasLayout()) {
-    dawn_desc.layout = AsDawnType(webgpu_desc->layout());
+    dawn_desc_info->dawn_desc.layout = AsDawnType(webgpu_desc->layout());
   }
+
   if (webgpu_desc->hasLabel()) {
-    label = webgpu_desc->label().Utf8();
-    dawn_desc.label = label.c_str();
+    dawn_desc_info->label = webgpu_desc->label().Utf8();
+    dawn_desc_info->dawn_desc.label = dawn_desc_info->label.c_str();
   }
 
-  OwnedProgrammableStageDescriptor vertex_stage_info =
-      AsDawnType(webgpu_desc->vertexStage());
-  dawn_desc.vertexStage = std::get<0>(vertex_stage_info);
-  OwnedProgrammableStageDescriptor fragment_stage_info;
+  dawn_desc_info->vertex_stage_info = AsDawnType(webgpu_desc->vertexStage());
+  dawn_desc_info->dawn_desc.vertexStage =
+      std::get<0>(dawn_desc_info->vertex_stage_info);
   if (webgpu_desc->hasFragmentStage()) {
-    fragment_stage_info = AsDawnType(webgpu_desc->fragmentStage());
-    dawn_desc.fragmentStage = &std::get<0>(fragment_stage_info);
-  } else {
-    dawn_desc.fragmentStage = nullptr;
+    dawn_desc_info->fragment_stage_info =
+        AsDawnType(webgpu_desc->fragmentStage());
+    dawn_desc_info->dawn_desc.fragmentStage =
+        &std::get<0>(dawn_desc_info->fragment_stage_info);
   }
 
-  dawn_desc.primitiveTopology =
+  dawn_desc_info->dawn_desc.primitiveTopology =
       AsDawnEnum<WGPUPrimitiveTopology>(webgpu_desc->primitiveTopology());
 
-  v8::Isolate* isolate = script_state->GetIsolate();
-  ExceptionState exception_state(isolate, ExceptionState::kConstructionContext,
-                                 "GPUVertexStateDescriptor");
-  WGPUVertexStateInfo vertex_state_info = GPUVertexStateAsWGPUVertexState(
-      isolate, webgpu_desc->vertexState(), exception_state);
-  WGPUVertexStateDescriptor dawn_vertex_state = std::get<0>(vertex_state_info);
-
-  dawn_desc.vertexState = &dawn_vertex_state;
+  dawn_desc_info->rasterization_state =
+      AsDawnType(webgpu_desc->rasterizationState());
+  dawn_desc_info->dawn_desc.rasterizationState =
+      &dawn_desc_info->rasterization_state;
 
-  if (exception_state.HadException()) {
-    return nullptr;
-  }
-
-  WGPURasterizationStateDescriptor rasterization_state;
-  rasterization_state = AsDawnType(webgpu_desc->rasterizationState());
-  dawn_desc.rasterizationState = &rasterization_state;
-
-  dawn_desc.sampleCount = webgpu_desc->sampleCount();
+  dawn_desc_info->dawn_desc.sampleCount = webgpu_desc->sampleCount();
 
-  WGPUDepthStencilStateDescriptor depth_stencil_state = {};
   if (webgpu_desc->hasDepthStencilState()) {
-    depth_stencil_state = AsDawnType(webgpu_desc->depthStencilState());
-    dawn_desc.depthStencilState = &depth_stencil_state;
-  } else {
-    dawn_desc.depthStencilState = nullptr;
+    dawn_desc_info->depth_stencil_state =
+        AsDawnType(webgpu_desc->depthStencilState());
+    dawn_desc_info->dawn_desc.depthStencilState =
+        &dawn_desc_info->depth_stencil_state;
   }
 
-  std::unique_ptr<WGPUColorStateDescriptor[]> color_states =
-      AsDawnType(webgpu_desc->colorStates());
-  dawn_desc.colorStateCount =
+  dawn_desc_info->color_states = AsDawnType(webgpu_desc->colorStates());
+  dawn_desc_info->dawn_desc.colorStateCount =
       static_cast<uint32_t>(webgpu_desc->colorStates().size());
+  dawn_desc_info->dawn_desc.colorStates = dawn_desc_info->color_states.get();
 
-  dawn_desc.colorStates = color_states.get();
+  dawn_desc_info->dawn_desc.sampleMask = webgpu_desc->sampleMask();
+  dawn_desc_info->dawn_desc.alphaToCoverageEnabled =
+      webgpu_desc->alphaToCoverageEnabled();
+}
+
+// static
+GPURenderPipeline* GPURenderPipeline::Create(
+    ScriptState* script_state,
+    GPUDevice* device,
+    const GPURenderPipelineDescriptor* webgpu_desc) {
+  DCHECK(device);
+  DCHECK(webgpu_desc);
 
-  dawn_desc.sampleMask = webgpu_desc->sampleMask();
-  dawn_desc.alphaToCoverageEnabled = webgpu_desc->alphaToCoverageEnabled();
+  OwnedRenderPipelineDescriptor dawn_desc_info;
+  v8::Isolate* isolate = script_state->GetIsolate();
+  ExceptionState exception_state(isolate, ExceptionState::kConstructionContext,
+                                 "GPUVertexStateDescriptor");
+  ConvertToDawnType(isolate, webgpu_desc, &dawn_desc_info, exception_state);
+  if (exception_state.HadException()) {
+    return nullptr;
+  }
 
   return MakeGarbageCollected<GPURenderPipeline>(
-      device, device->GetProcs().deviceCreateRenderPipeline(device->GetHandle(),
-                                                            &dawn_desc));
+      device, device->GetProcs().deviceCreateRenderPipeline(
+                  device->GetHandle(), &dawn_desc_info.dawn_desc));
 }
 
 GPURenderPipeline::GPURenderPipeline(GPUDevice* device,

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();