[WebGPU] Add the entry point of CreateReadyComputePipeline

BUG=dawn:529

Change-Id: If23c63afeb72cae42bf800a945b5af22626cfdb2
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2567635
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Austin Eng <enga@chromium.org>
Cr-Commit-Position: refs/heads/master@{#832717}

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

@@ -6,7 +6,6 @@
 
 #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_compute_pipeline_descriptor.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_programmable_stage_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"
@@ -14,26 +13,41 @@
 
 namespace blink {
 
-// static
-GPUComputePipeline* GPUComputePipeline::Create(
-    GPUDevice* device,
-    const GPUComputePipelineDescriptor* webgpu_desc) {
-  DCHECK(device);
+WGPUComputePipelineDescriptor AsDawnType(
+    const GPUComputePipelineDescriptor* webgpu_desc,
+    std::string* label,
+    OwnedProgrammableStageDescriptor* computeStageDescriptor) {
   DCHECK(webgpu_desc);
+  DCHECK(label);
+  DCHECK(computeStageDescriptor);
 
-  std::string label;
   WGPUComputePipelineDescriptor dawn_desc = {};
   dawn_desc.nextInChain = nullptr;
   if (webgpu_desc->hasLayout()) {
     dawn_desc.layout = AsDawnType(webgpu_desc->layout());
   }
   if (webgpu_desc->hasLabel()) {
-    label = webgpu_desc->label().Utf8();
-    dawn_desc.label = label.c_str();
+    *label = webgpu_desc->label().Utf8();
+    dawn_desc.label = label->c_str();
   }
 
-  auto compute_stage = AsDawnType(webgpu_desc->computeStage());
-  dawn_desc.computeStage = std::get<0>(compute_stage);
+  *computeStageDescriptor = AsDawnType(webgpu_desc->computeStage());
+  dawn_desc.computeStage = std::get<0>(*computeStageDescriptor);
+
+  return dawn_desc;
+}
+
+// static
+GPUComputePipeline* GPUComputePipeline::Create(
+    GPUDevice* device,
+    const GPUComputePipelineDescriptor* webgpu_desc) {
+  DCHECK(device);
+  DCHECK(webgpu_desc);
+
+  std::string label;
+  OwnedProgrammableStageDescriptor computeStageDescriptor;
+  WGPUComputePipelineDescriptor dawn_desc =
+      AsDawnType(webgpu_desc, &label, &computeStageDescriptor);
 
   return MakeGarbageCollected<GPUComputePipeline>(
       device, device->GetProcs().deviceCreateComputePipeline(

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

@@ -5,6 +5,7 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_WEBGPU_GPU_COMPUTE_PIPELINE_H_
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_WEBGPU_GPU_COMPUTE_PIPELINE_H_
 
+#include "third_party/blink/renderer/modules/webgpu/dawn_conversions.h"
 #include "third_party/blink/renderer/modules/webgpu/dawn_object.h"
 
 namespace blink {
@@ -12,6 +13,11 @@ namespace blink {
 class GPUBindGroupLayout;
 class GPUComputePipelineDescriptor;
 
+WGPUComputePipelineDescriptor AsDawnType(
+    const GPUComputePipelineDescriptor* webgpu_desc,
+    std::string* label,
+    OwnedProgrammableStageDescriptor* computeStageDescriptor);
+
 class GPUComputePipeline : public DawnObject<WGPUComputePipeline> {
   DEFINE_WRAPPERTYPEINFO();
 

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

@@ -7,6 +7,7 @@
 #include "gpu/command_buffer/client/webgpu_interface.h"
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
+#include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_compute_pipeline_descriptor.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_device_descriptor.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_extension_name.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_gpu_uncaptured_error_event_init.h"
@@ -148,6 +149,33 @@ void GPUDevice::OnDeviceLostError(const char* message) {
   }
 }
 
+void GPUDevice::OnCreateReadyComputePipelineCallback(
+    ScriptPromiseResolver* resolver,
+    WGPUCreateReadyPipelineStatus status,
+    WGPUComputePipeline compute_pipeline,
+    const char* message) {
+  switch (status) {
+    case WGPUCreateReadyPipelineStatus_Success: {
+      resolver->Resolve(
+          MakeGarbageCollected<GPUComputePipeline>(this, compute_pipeline));
+      break;
+    }
+
+    case WGPUCreateReadyPipelineStatus_Error:
+    case WGPUCreateReadyPipelineStatus_DeviceLost:
+    case WGPUCreateReadyPipelineStatus_DeviceDestroyed:
+    case WGPUCreateReadyPipelineStatus_Unknown: {
+      resolver->Reject(MakeGarbageCollected<DOMException>(
+          DOMExceptionCode::kOperationError, message));
+      break;
+    }
+
+    default: {
+      NOTREACHED();
+    }
+  }
+}
+
 GPUAdapter* GPUDevice::adapter() const {
   return adapter_;
 }
@@ -211,6 +239,29 @@ GPUComputePipeline* GPUDevice::createComputePipeline(
   return GPUComputePipeline::Create(this, descriptor);
 }
 
+ScriptPromise GPUDevice::createReadyComputePipeline(
+    ScriptState* script_state,
+    const GPUComputePipelineDescriptor* descriptor) {
+  auto* resolver = MakeGarbageCollected<ScriptPromiseResolver>(script_state);
+  ScriptPromise promise = resolver->Promise();
+
+  std::string label;
+  OwnedProgrammableStageDescriptor computeStageDescriptor;
+  WGPUComputePipelineDescriptor dawn_desc =
+      AsDawnType(descriptor, &label, &computeStageDescriptor);
+
+  auto* callback =
+      BindDawnCallback(&GPUDevice::OnCreateReadyComputePipelineCallback,
+                       WrapPersistent(this), WrapPersistent(resolver));
+  GetProcs().deviceCreateReadyComputePipeline(GetHandle(), &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;
+}
+
 GPUCommandEncoder* GPUDevice::createCommandEncoder(
     const GPUCommandEncoderDescriptor* descriptor) {
   return GPUCommandEncoder::Create(this, 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 createReadyComputePipeline(
+      ScriptState* script_state,
+      const GPUComputePipelineDescriptor* descriptor);
 
   GPUCommandEncoder* createCommandEncoder(
       const GPUCommandEncoderDescriptor* descriptor);
@@ -123,6 +126,12 @@ class GPUDevice final : public EventTargetWithInlineData,
                                WGPUErrorType type,
                                const char* message);
 
+  void OnCreateReadyComputePipelineCallback(
+      ScriptPromiseResolver* resolver,
+      WGPUCreateReadyPipelineStatus status,
+      WGPUComputePipeline compute_pipeline,
+      const char* message);
+
   Member<GPUAdapter> adapter_;
   Vector<String> extension_name_list_;
   Member<GPUQueue> queue_;

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

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