Reland "WebGPU: Create GPUDevice in the callback of RequestDeviceAsync()"

This reverts commit 7dd53909.

Reason for revert: this CL is not the root cause of the try bot failures.

Original change's description:
> Revert "WebGPU: Create GPUDevice in the callback of RequestDeviceAsync()"
> 
> This reverts commit 2625327a.
> 
> Reason for revert: This is likely breaking https://ci.chromium.org/p/chromium/builders/ci/Mac%20Retina%20Debug%20%28AMD%29
> 
> Original change's description:
> > WebGPU: Create GPUDevice in the callback of RequestDeviceAsync()
> > 
> > This patch updates RequestDevice() into an asynchronous function
> > RequestDeviceAsync() and moves the creation of GPUDevice into the
> > callback function passed as a parameter of RequestDeviceAsync().
> > 
> > BUG=chromium:996713
> > 
> > Change-Id: I7208a107670ca6e79ad3a4a3107f35ae26330edf
> > Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1955171
> > Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
> > Reviewed-by: Austin Eng <enga@chromium.org>
> > Reviewed-by: Kai Ninomiya <kainino@chromium.org>
> > Reviewed-by: Kenneth Russell <kbr@chromium.org>
> > Cr-Commit-Position: refs/heads/master@{#723595}
> 
> TBR=zmo@chromium.org,kbr@chromium.org,cwallez@chromium.org,shaobo.yan@intel.com,yunchao.he@intel.com,jiawei.shao@intel.com,yang.gu@intel.com,kainino@chromium.org,jiajie.hu@intel.com,enga@chromium.org,hao.x.li@intel.com
> 
> Change-Id: I7f78422e0c841a17692a7030690fe911202aebeb
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Bug: chromium:996713
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1961353
> Reviewed-by: Melissa Zhang <melzhang@chromium.org>
> Commit-Queue: Melissa Zhang <melzhang@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#723712}

TBR=zmo@chromium.org,kbr@chromium.org,cwallez@chromium.org,shaobo.yan@intel.com,yunchao.he@intel.com,jiawei.shao@intel.com,yang.gu@intel.com,kainino@chromium.org,jiajie.hu@intel.com,enga@chromium.org,hao.x.li@intel.com,melzhang@chromium.org

Change-Id: I5fb3d180e89a88803e93668b57dc5e5b3ea5f481
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: chromium:996713
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1963373Reviewed-by: Melissa Zhang <melzhang@chromium.org>
Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
Cr-Commit-Position: refs/heads/master@{#724049}

gpu/command_buffer/build_webgpu_cmd_buffer.py

@@ -70,7 +70,8 @@ _FUNCTION_INFO = {
     'impl_func': False,
     'internal': True,
     'data_transfer_methods': ['shm'],
-    'cmd_args': 'uint32_t adapter_service_id, '
+    'cmd_args': 'uint32_t request_device_serial, '
+                'uint32_t adapter_service_id, '
                 'uint32_t request_device_properties_shm_id, '
                 'uint32_t request_device_properties_shm_offset, '
                 'uint32_t request_device_properties_size',

gpu/command_buffer/client/webgpu_cmd_helper_autogen.h

@@ -51,13 +51,15 @@ void RequestAdapter(uint32_t request_adapter_serial,
   }
 }
 
-void RequestDevice(uint32_t adapter_service_id,
+void RequestDevice(uint32_t request_device_serial,
+                   uint32_t adapter_service_id,
                    uint32_t request_device_properties_shm_id,
                    uint32_t request_device_properties_shm_offset,
                    uint32_t request_device_properties_size) {
   webgpu::cmds::RequestDevice* c = GetCmdSpace<webgpu::cmds::RequestDevice>();
   if (c) {
-    c->Init(adapter_service_id, request_device_properties_shm_id,
+    c->Init(request_device_serial, adapter_service_id,
+            request_device_properties_shm_id,
             request_device_properties_shm_offset,
             request_device_properties_size);
   }

gpu/command_buffer/client/webgpu_implementation.cc

@@ -285,6 +285,26 @@ void WebGPUImplementation::OnGpuControlReturnData(
       std::move(request_callback).Run(adapter_service_id, adapter_properties);
       request_adapter_callback_map_.erase(request_callback_iter);
     } break;
+    case DawnReturnDataType::kRequestedDeviceReturnInfo: {
+      const cmds::DawnReturnRequestDeviceInfo* returned_request_device_info =
+          reinterpret_cast<const cmds::DawnReturnRequestDeviceInfo*>(
+              data.data());
+
+      GLuint request_device_serial =
+          returned_request_device_info->request_device_serial;
+      auto request_callback_iter =
+          request_device_callback_map_.find(request_device_serial);
+      if (request_callback_iter == request_device_callback_map_.end()) {
+        // TODO(jiawei.shao@intel.com): Lose the context.
+        NOTREACHED();
+        break;
+      }
+      auto& request_callback = request_callback_iter->second;
+      bool is_request_device_success =
+          returned_request_device_info->is_request_device_success;
+      std::move(request_callback).Run(is_request_device_success);
+      request_device_callback_map_.erase(request_callback_iter);
+    } break;
     default:
       // TODO(jiawei.shao@intel.com): Lose the context.
       NOTREACHED();
@@ -417,12 +437,29 @@ bool WebGPUImplementation::RequestAdapterAsync(
   return true;
 }
 
-bool WebGPUImplementation::RequestDevice(
+uint32_t WebGPUImplementation::NextRequestDeviceSerial() {
+  return ++request_device_serial_;
+}
+
+bool WebGPUImplementation::RequestDeviceAsync(
     uint32_t requested_adapter_id,
-    const WGPUDeviceProperties* requested_device_properties) {
+    const WGPUDeviceProperties* requested_device_properties,
+    base::OnceCallback<void(bool)> request_device_callback) {
 #if BUILDFLAG(USE_DAWN)
+  uint32_t request_device_serial = NextRequestDeviceSerial();
+
+  // Avoid the overflow of request_device_serial and old slot being reused.
+  if (request_device_callback_map_.find(request_device_serial) !=
+      request_device_callback_map_.end()) {
+    return false;
+  }
+
+  request_device_callback_map_[request_device_serial] =
+      std::move(request_device_callback);
+
   if (!requested_device_properties) {
-    helper_->RequestDevice(requested_adapter_id, 0, 0, 0);
+    helper_->RequestDevice(request_device_serial_, requested_adapter_id, 0, 0,
+                           0);
     return true;
   }
 
@@ -440,10 +477,13 @@ bool WebGPUImplementation::RequestDevice(
   dawn_wire::SerializeWGPUDeviceProperties(
       requested_device_properties,
       reinterpret_cast<char*>(transfer_buffer.address()));
-  helper_->RequestDevice(requested_adapter_id, transfer_buffer.shm_id(),
-                         transfer_buffer.offset(),
+  helper_->RequestDevice(request_device_serial, requested_adapter_id,
+                         transfer_buffer.shm_id(), transfer_buffer.offset(),
                          serialized_device_properties_size);
   transfer_buffer.Release();
+
+  helper_->Flush();
+
   return true;
 #else
   NOTREACHED();

gpu/command_buffer/client/webgpu_implementation.h

@@ -123,14 +123,16 @@ class WEBGPU_EXPORT WebGPUImplementation final
       PowerPreference power_preference,
       base::OnceCallback<void(uint32_t, const WGPUDeviceProperties&)>
           request_adapter_callback) override;
-  bool RequestDevice(
+  bool RequestDeviceAsync(
       uint32_t requested_adapter_id,
-      const WGPUDeviceProperties* requested_device_properties) override;
+      const WGPUDeviceProperties* requested_device_properties,
+      base::OnceCallback<void(bool)> request_device_callback) override;
 
  private:
   const char* GetLogPrefix() const { return "webgpu"; }
   void CheckGLError() {}
   uint32_t NextRequestAdapterSerial();
+  uint32_t NextRequestDeviceSerial();
 
   WebGPUCmdHelper* helper_;
 #if BUILDFLAG(USE_DAWN)
@@ -151,6 +153,10 @@ class WEBGPU_EXPORT WebGPUImplementation final
       request_adapter_callback_map_;
   uint32_t request_adapter_serial_ = 0;
 
+  base::flat_map<uint32_t, base::OnceCallback<void(bool)>>
+      request_device_callback_map_;
+  uint32_t request_device_serial_ = 0;
+
   DISALLOW_COPY_AND_ASSIGN(WebGPUImplementation);
 };
 

gpu/command_buffer/client/webgpu_interface.h

@@ -34,9 +34,10 @@ class WebGPUInterface : public InterfaceBase {
       PowerPreference power_preference,
       base::OnceCallback<void(uint32_t, const WGPUDeviceProperties&)>
           request_adapter_callback) = 0;
-  virtual bool RequestDevice(
+  virtual bool RequestDeviceAsync(
       uint32_t adapter_service_id,
-      const WGPUDeviceProperties* requested_device_properties) = 0;
+      const WGPUDeviceProperties* requested_device_properties,
+      base::OnceCallback<void(bool)> request_device_callback) = 0;
 
 // Include the auto-generated part of this class. We split this because
 // it means we can easily edit the non-auto generated parts right here in

gpu/command_buffer/client/webgpu_interface_stub.cc

@@ -35,9 +35,10 @@ bool WebGPUInterfaceStub::RequestAdapterAsync(
         request_adapter_callback) {
   return false;
 }
-bool WebGPUInterfaceStub::RequestDevice(
+bool WebGPUInterfaceStub::RequestDeviceAsync(
     uint32_t adapter_service_id,
-    const WGPUDeviceProperties* requested_device_properties) {
+    const WGPUDeviceProperties* requested_device_properties,
+    base::OnceCallback<void(bool)> request_device_callback) {
   return false;
 }
 

gpu/command_buffer/client/webgpu_interface_stub.h

@@ -31,9 +31,10 @@ class WebGPUInterfaceStub : public WebGPUInterface {
       PowerPreference power_preference,
       base::OnceCallback<void(uint32_t, const WGPUDeviceProperties&)>
           request_adapter_callback) override;
-  bool RequestDevice(
+  bool RequestDeviceAsync(
       uint32_t adapter_service_id,
-      const WGPUDeviceProperties* requested_device_properties) override;
+      const WGPUDeviceProperties* requested_device_properties,
+      base::OnceCallback<void(bool)> request_device_callback) override;
 
 // Include the auto-generated part of this class. We split this because
 // it means we can easily edit the non-auto generated parts right here in

gpu/command_buffer/common/webgpu_cmd_enums.h

@@ -18,6 +18,7 @@ enum class PowerPreference : uint32_t {
 enum class DawnReturnDataType : uint32_t {
   kDawnCommands,
   kRequestedDawnAdapterProperties,
+  kRequestedDeviceReturnInfo,
   kNumDawnReturnDataType
 };
 

gpu/command_buffer/common/webgpu_cmd_format.h

@@ -51,6 +51,16 @@ static_assert(offsetof(DawnReturnAdapterInfo, deserialized_buffer) %
               "The offset of deserialized_buffer must align to "
               "GPU_DAWN_RETURN_DATA_ALIGNMENT");
 
+struct DawnReturnRequestDeviceInfo {
+  DawnReturnDataHeader return_data_header = {
+      DawnReturnDataType::kRequestedDeviceReturnInfo};
+  uint32_t request_device_serial;
+  bool is_request_device_success;
+};
+
+static_assert(offsetof(DawnReturnRequestDeviceInfo, return_data_header) == 0,
+              "The offset of return_data_header must be 0");
+
 // Command buffer is GPU_COMMAND_BUFFER_ENTRY_ALIGNMENT byte aligned.
 #pragma pack(push, 4)
 static_assert(GPU_COMMAND_BUFFER_ENTRY_ALIGNMENT == 4,

gpu/command_buffer/common/webgpu_cmd_format_autogen.h

@@ -216,11 +216,13 @@ struct RequestDevice {
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
-  void Init(uint32_t _adapter_service_id,
+  void Init(uint32_t _request_device_serial,
+            uint32_t _adapter_service_id,
             uint32_t _request_device_properties_shm_id,
             uint32_t _request_device_properties_shm_offset,
             uint32_t _request_device_properties_size) {
     SetHeader();
+    request_device_serial = _request_device_serial;
     adapter_service_id = _adapter_service_id;
     request_device_properties_shm_id = _request_device_properties_shm_id;
     request_device_properties_shm_offset =
@@ -229,38 +231,43 @@ struct RequestDevice {
   }
 
   void* Set(void* cmd,
+            uint32_t _request_device_serial,
             uint32_t _adapter_service_id,
             uint32_t _request_device_properties_shm_id,
             uint32_t _request_device_properties_shm_offset,
             uint32_t _request_device_properties_size) {
     static_cast<ValueType*>(cmd)->Init(
-        _adapter_service_id, _request_device_properties_shm_id,
+        _request_device_serial, _adapter_service_id,
+        _request_device_properties_shm_id,
         _request_device_properties_shm_offset, _request_device_properties_size);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
+  uint32_t request_device_serial;
   uint32_t adapter_service_id;
   uint32_t request_device_properties_shm_id;
   uint32_t request_device_properties_shm_offset;
   uint32_t request_device_properties_size;
 };
 
-static_assert(sizeof(RequestDevice) == 20,
-              "size of RequestDevice should be 20");
+static_assert(sizeof(RequestDevice) == 24,
+              "size of RequestDevice should be 24");
 static_assert(offsetof(RequestDevice, header) == 0,
               "offset of RequestDevice header should be 0");
-static_assert(offsetof(RequestDevice, adapter_service_id) == 4,
-              "offset of RequestDevice adapter_service_id should be 4");
+static_assert(offsetof(RequestDevice, request_device_serial) == 4,
+              "offset of RequestDevice request_device_serial should be 4");
+static_assert(offsetof(RequestDevice, adapter_service_id) == 8,
+              "offset of RequestDevice adapter_service_id should be 8");
 static_assert(
-    offsetof(RequestDevice, request_device_properties_shm_id) == 8,
-    "offset of RequestDevice request_device_properties_shm_id should be 8");
+    offsetof(RequestDevice, request_device_properties_shm_id) == 12,
+    "offset of RequestDevice request_device_properties_shm_id should be 12");
 static_assert(offsetof(RequestDevice, request_device_properties_shm_offset) ==
-                  12,
+                  16,
               "offset of RequestDevice request_device_properties_shm_offset "
-              "should be 12");
+              "should be 16");
 static_assert(
-    offsetof(RequestDevice, request_device_properties_size) == 16,
-    "offset of RequestDevice request_device_properties_size should be 16");
+    offsetof(RequestDevice, request_device_properties_size) == 20,
+    "offset of RequestDevice request_device_properties_size should be 20");
 
 #endif  // GPU_COMMAND_BUFFER_COMMON_WEBGPU_CMD_FORMAT_AUTOGEN_H_

gpu/command_buffer/common/webgpu_cmd_format_test_autogen.h

@@ -95,15 +95,17 @@ TEST_F(WebGPUFormatTest, RequestDevice) {
   cmds::RequestDevice& cmd = *GetBufferAs<cmds::RequestDevice>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<uint32_t>(11), static_cast<uint32_t>(12),
-              static_cast<uint32_t>(13), static_cast<uint32_t>(14));
+              static_cast<uint32_t>(13), static_cast<uint32_t>(14),
+              static_cast<uint32_t>(15));
   EXPECT_EQ(static_cast<uint32_t>(cmds::RequestDevice::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<uint32_t>(11), cmd.adapter_service_id);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.request_device_properties_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13),
+  EXPECT_EQ(static_cast<uint32_t>(11), cmd.request_device_serial);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.adapter_service_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.request_device_properties_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14),
             cmd.request_device_properties_shm_offset);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.request_device_properties_size);
+  EXPECT_EQ(static_cast<uint32_t>(15), cmd.request_device_properties_size);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 

gpu/command_buffer/service/webgpu_decoder_impl.cc

@@ -49,6 +49,9 @@ class WireServerCommandSerializer : public dawn_wire::CommandSerializer {
                              uint32_t adapter_server_id,
                              const dawn_native::Adapter& adapter);
 
+  void SendRequestedDeviceInfo(uint32_t request_device_serial,
+                               bool is_request_device_success);
+
  private:
   DecoderClient* client_;
   std::vector<uint8_t> buffer_;
@@ -143,6 +146,21 @@ void WireServerCommandSerializer::SendAdapterProperties(
       serialized_buffer.size()));
 }
 
+void WireServerCommandSerializer::SendRequestedDeviceInfo(
+    uint32_t request_device_serial,
+    bool is_request_device_success) {
+  cmds::DawnReturnRequestDeviceInfo return_request_device_info;
+  DCHECK_EQ(DawnReturnDataType::kRequestedDeviceReturnInfo,
+            return_request_device_info.return_data_header.return_data_type);
+  return_request_device_info.request_device_serial = request_device_serial;
+  return_request_device_info.is_request_device_success =
+      is_request_device_success;
+
+  client_->HandleReturnData(base::make_span(
+      reinterpret_cast<const uint8_t*>(&return_request_device_info),
+      sizeof(return_request_device_info)));
+}
+
 dawn_native::DeviceType PowerPreferenceToDawnDeviceType(
     PowerPreference power_preference) {
   switch (power_preference) {
@@ -504,7 +522,7 @@ error::Error WebGPUDecoderImpl::InitDawnDeviceAndSetWireServer(
 
   wgpu_device_ = dawn_adapters_[requested_adapter_index].CreateDevice();
   if (wgpu_device_ == nullptr) {
-    return error::kLostContext;
+    return error::kInvalidArguments;
   }
 
   dawn_wire::WireServerDescriptor descriptor = {};
@@ -697,6 +715,8 @@ error::Error WebGPUDecoderImpl::HandleRequestDevice(
   const volatile webgpu::cmds::RequestDevice& c =
       *static_cast<const volatile webgpu::cmds::RequestDevice*>(cmd_data);
 
+  uint32_t request_device_serial =
+      static_cast<uint32_t>(c.request_device_serial);
   uint32_t adapter_service_id = static_cast<uint32_t>(c.adapter_service_id);
   uint32_t request_device_properties_shm_id =
       static_cast<uint32_t>(c.request_device_properties_shm_id);
@@ -706,22 +726,25 @@ error::Error WebGPUDecoderImpl::HandleRequestDevice(
       static_cast<uint32_t>(c.request_device_properties_size);
 
   WGPUDeviceProperties device_properties = {};
-  if (!request_device_properties_size) {
-    return InitDawnDeviceAndSetWireServer(adapter_service_id,
-                                          device_properties);
-  }
+  if (request_device_properties_size) {
+    const volatile char* shm_device_properties =
+        GetSharedMemoryAs<const volatile char*>(
+            request_device_properties_shm_id,
+            request_device_properties_shm_offset,
+            request_device_properties_size);
+    if (!shm_device_properties) {
+      return error::kOutOfBounds;
+    }
 
-  const volatile char* shm_device_properties =
-      GetSharedMemoryAs<const volatile char*>(
-          request_device_properties_shm_id,
-          request_device_properties_shm_offset, request_device_properties_size);
-  if (!shm_device_properties) {
-    return error::kOutOfBounds;
+    dawn_wire::DeserializeWGPUDeviceProperties(&device_properties,
+                                               shm_device_properties);
   }
 
-  dawn_wire::DeserializeWGPUDeviceProperties(&device_properties,
-                                             shm_device_properties);
-  return InitDawnDeviceAndSetWireServer(adapter_service_id, device_properties);
+  error::Error init_dawn_device_error =
+      InitDawnDeviceAndSetWireServer(adapter_service_id, device_properties);
+  wire_serializer_->SendRequestedDeviceInfo(
+      request_device_serial, !error::IsError(init_dawn_device_error));
+  return init_dawn_device_error;
 }
 
 error::Error WebGPUDecoderImpl::HandleDawnCommands(

gpu/command_buffer/service/webgpu_decoder_unittest.cc

@@ -64,8 +64,9 @@ class WebGPUDecoderTest : public ::testing::Test {
     ASSERT_EQ(error::kNoError, ExecuteCmd(requestAdapterCmd));
 
     constexpr uint32_t kAdapterServiceID = 0;
+    constexpr uint32_t kRequestDeviceSerial = 0;
     cmds::RequestDevice requestDeviceCmd;
-    requestDeviceCmd.Init(kAdapterServiceID, 0, 0, 0);
+    requestDeviceCmd.Init(kRequestDeviceSerial, kAdapterServiceID, 0, 0, 0);
     ASSERT_EQ(error::kNoError, ExecuteCmd(requestDeviceCmd));
 
     factory_ = std::make_unique<SharedImageFactory>(

gpu/command_buffer/tests/webgpu_fence_unittest.cc

@@ -54,7 +54,8 @@ TEST_F(WebGPUFenceTest, InitialValue) {
     return;
   }
   constexpr uint32_t kAdapterID = 0;
-  webgpu()->RequestDevice(kAdapterID, nullptr);
+  webgpu()->RequestDeviceAsync(kAdapterID, nullptr,
+                               base::BindOnce(&OnRequestDeviceCallback));
   wgpu::Device device = wgpu::Device::Acquire(webgpu()->GetDefaultDevice());
   wgpu::Queue queue = device.CreateQueue();
   {
@@ -76,7 +77,8 @@ TEST_F(WebGPUFenceTest, GetCompletedValue) {
     return;
   }
   constexpr uint32_t kAdapterID = 0;
-  webgpu()->RequestDevice(kAdapterID, nullptr);
+  webgpu()->RequestDeviceAsync(kAdapterID, nullptr,
+                               base::BindOnce(&OnRequestDeviceCallback));
   wgpu::Device device = wgpu::Device::Acquire(webgpu()->GetDefaultDevice());
   wgpu::Queue queue = device.CreateQueue();
   wgpu::FenceDescriptor fence_desc{nullptr, nullptr, 0};
@@ -94,7 +96,8 @@ TEST_F(WebGPUFenceTest, OnCompletion) {
     return;
   }
   constexpr uint32_t kAdapterID = 0;
-  webgpu()->RequestDevice(kAdapterID, nullptr);
+  webgpu()->RequestDeviceAsync(kAdapterID, nullptr,
+                               base::BindOnce(&OnRequestDeviceCallback));
   wgpu::Device device = wgpu::Device::Acquire(webgpu()->GetDefaultDevice());
   wgpu::Queue queue = device.CreateQueue();
   wgpu::FenceDescriptor fence_desc{nullptr, nullptr, 0};
@@ -115,7 +118,8 @@ TEST_F(WebGPUFenceTest, SignalManyTimes) {
     return;
   }
   constexpr uint32_t kAdapterID = 0;
-  webgpu()->RequestDevice(kAdapterID, nullptr);
+  webgpu()->RequestDeviceAsync(kAdapterID, nullptr,
+                               base::BindOnce(&OnRequestDeviceCallback));
   wgpu::Device device = wgpu::Device::Acquire(webgpu()->GetDefaultDevice());
   wgpu::Queue queue = device.CreateQueue();
   wgpu::FenceDescriptor fence_desc{nullptr, nullptr, 0};

gpu/command_buffer/tests/webgpu_mailbox_unittest.cc

@@ -91,7 +91,8 @@ TEST_F(WebGPUMailboxTest, WriteToMailboxThenReadFromIt) {
   webgpu()->WaitSyncTokenCHROMIUM(mailbox_produced_token.GetConstData());
 
   constexpr uint32_t kAdapterID = 0;
-  webgpu()->RequestDevice(kAdapterID, nullptr);
+  webgpu()->RequestDeviceAsync(kAdapterID, nullptr,
+                               base::BindOnce(&OnRequestDeviceCallback));
   wgpu::Device device = wgpu::Device::Acquire(webgpu()->GetDefaultDevice());
 
   // Part 1: Write to the texture using Dawn
@@ -211,7 +212,8 @@ TEST_F(WebGPUMailboxTest, ErrorWhenUsingTextureAfterDissociate) {
 
   // Create the device, and expect a validation error.
   constexpr uint32_t kAdapterID = 0;
-  webgpu()->RequestDevice(kAdapterID, nullptr);
+  webgpu()->RequestDeviceAsync(kAdapterID, nullptr,
+                               base::BindOnce(&OnRequestDeviceCallback));
   wgpu::Device device = wgpu::Device::Acquire(webgpu()->GetDefaultDevice());
   device.SetUncapturedErrorCallback(ToMockUncapturedErrorCallback, 0);
 

gpu/command_buffer/tests/webgpu_test.cc

@@ -26,6 +26,8 @@ void OnRequestAdapterCallback(uint32_t adapter_server_id,
 
 }  // anonymous namespace
 
+void OnRequestDeviceCallback(bool is_request_device_success) {}
+
 WebGPUTest::Options::Options() = default;
 
 WebGPUTest::WebGPUTest() = default;

gpu/command_buffer/tests/webgpu_test.h

@@ -21,6 +21,8 @@ namespace gpu {
 class SharedImageInterface;
 class WebGPUInProcessContext;
 
+void OnRequestDeviceCallback(bool is_request_device_success);
+
 namespace webgpu {
 
 class WebGPUInterface;

gpu/command_buffer/webgpu_cmd_buffer_functions.txt

@@ -10,4 +10,4 @@ GL_APICALL void GL_APIENTRY wgDawnCommands (const char* commands, size_t size);
 GL_APICALL void GL_APIENTRY wgAssociateMailbox (GLuint device_id, GLuint device_generation, GLuint id, GLuint generation, GLuint usage, const GLbyte* mailbox);
 GL_APICALL void GL_APIENTRY wgDissociateMailbox (GLuint texture_id, GLuint texture_generation);
 GL_APICALL void GL_APIENTRY wgRequestAdapter (GLuint request_adapter_serial, EnumClassPowerPreference power_preference = PowerPreference::kDefault);
-GL_APICALL void GL_APIENTRY wgRequestDevice (GLuint adapter_service_id, const char* dawn_request_device_properties, size_t request_device_properties_size);
+GL_APICALL void GL_APIENTRY wgRequestDevice (GLuint request_device_serial, GLuint adapter_service_id, const char* dawn_request_device_properties, size_t request_device_properties_size);

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

@@ -6,6 +6,7 @@
 
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_object_builder.h"
+#include "third_party/blink/renderer/core/dom/dom_exception.h"
 #include "third_party/blink/renderer/modules/webgpu/gpu_device.h"
 #include "third_party/blink/renderer/modules/webgpu/gpu_device_descriptor.h"
 #include "third_party/blink/renderer/modules/webgpu/gpu_extensions.h"
@@ -56,22 +57,36 @@ ScriptValue GPUAdapter::extensions(ScriptState* script_state) const {
   return object_builder.GetScriptValue();
 }
 
+void GPUAdapter::OnRequestDeviceCallback(ScriptPromiseResolver* resolver,
+                                         const GPUDeviceDescriptor* descriptor,
+                                         bool is_request_device_success) {
+  if (is_request_device_success) {
+    ExecutionContext* execution_context = resolver->GetExecutionContext();
+    GPUDevice* device = GPUDevice::Create(
+        execution_context, GetDawnControlClient(), this, descriptor);
+    resolver->Resolve(device);
+  } else {
+    resolver->Reject(MakeGarbageCollected<DOMException>(
+        DOMExceptionCode::kOperationError,
+        "Fail to request GPUDevice with the given GPUDeviceDescriptor"));
+  }
+}
+
 ScriptPromise GPUAdapter::requestDevice(ScriptState* script_state,
                                         const GPUDeviceDescriptor* descriptor) {
   auto* resolver = MakeGarbageCollected<ScriptPromiseResolver>(script_state);
   ScriptPromise promise = resolver->Promise();
 
   WGPUDeviceProperties requested_device_properties = AsDawnType(descriptor);
-  GetInterface()->RequestDevice(adapter_service_id_,
-                                &requested_device_properties);
 
-  // TODO(jiawei.shao@intel.com): create GPUDevice in the callback of
-  // GetInterface()->RequestDevice().
-  ExecutionContext* execution_context = ExecutionContext::From(script_state);
-  GPUDevice* device = GPUDevice::Create(
-      execution_context, GetDawnControlClient(), this, descriptor);
+  if (!GetInterface()->RequestDeviceAsync(
+          adapter_service_id_, &requested_device_properties,
+          WTF::Bind(&GPUAdapter::OnRequestDeviceCallback, WrapPersistent(this),
+                    WrapPersistent(resolver), WrapPersistent(descriptor)))) {
+    resolver->Reject(MakeGarbageCollected<DOMException>(
+        DOMExceptionCode::kOperationError, "Unknown error creating GPUDevice"));
+  }
 
-  resolver->Resolve(device);
   return promise;
 }
 

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

@@ -16,6 +16,7 @@
 namespace blink {
 
 class GPUDeviceDescriptor;
+class ScriptPromiseResolver;
 
 class GPUAdapter final : public ScriptWrappable, public DawnObjectBase {
   DEFINE_WRAPPERTYPEINFO();
@@ -38,6 +39,10 @@ class GPUAdapter final : public ScriptWrappable, public DawnObjectBase {
                               const GPUDeviceDescriptor* descriptor);
 
  private:
+  void OnRequestDeviceCallback(ScriptPromiseResolver* resolver,
+                               const GPUDeviceDescriptor* descriptor,
+                               bool is_request_device_success);
+
   String name_;
   uint32_t adapter_service_id_;
   WGPUDeviceProperties adapter_properties_;