Implement requesting WebGPU adapter with GPURequestAdapterOptions

This patch is the first one to support creating GPUDevice with extensions.
In this patch we implements requesting a WebGPU adapter with options.

Now we only support "powerPreference" as an option to request an adapter.
The option is treated as an enum and passed from Blink to the WebGPU
command buffer to create a Dawn adapter. The "high-performance" adapter
refers to the discrete GPU, and the "low-power" adapter refers to the
integrated GPU. The default adapter will be the one that refers to the
discrete GPU.

BUG=chromium:996713

Change-Id: Iffb98410cf2a2d6d4eb127bdd09a0886099db127
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1794033Reviewed-by: Kenneth Russell <kbr@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
Reviewed-by: Austin Eng <enga@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
Cr-Commit-Position: refs/heads/master@{#699598}

gpu/command_buffer/build_webgpu_cmd_buffer.py

@@ -17,6 +17,16 @@ import build_cmd_buffer_lib
 #
 # Options are documented in build_gles2_cmd_buffer.py/build_raster_cmd_buffer.py
 _NAMED_TYPE_INFO = {
+  'PowerPreference': {
+    'type': 'PowerPreference',
+    'valid': [
+      'PowerPreference::kHighPerformance',
+      'PowerPreference::kLowPower',
+    ],
+    'invalid': [
+      'PowerPreference::kNumPowerPreferences',
+    ],
+  }
 }
 
 # A function info object specifies the type and other special data for the
@@ -50,6 +60,10 @@ _FUNCTION_INFO = {
   'DissociateMailbox': {
     'trace_level': 1,
   },
+  'RequestAdapter': {
+    'impl_func': False,
+    'cmd_args': 'uint32_t power_preference'
+  },
 }
 
 def main(argv):

gpu/command_buffer/client/BUILD.gn

@@ -219,6 +219,7 @@ source_set("webgpu_interface") {
   deps = [
     ":interface_base",
     "//base",
+    "//gpu/command_buffer/common:webgpu",
   ]
 }
 

gpu/command_buffer/client/webgpu_cmd_helper_autogen.h

@@ -43,4 +43,11 @@ void DissociateMailbox(GLuint texture_id, GLuint texture_generation) {
   }
 }
 
+void RequestAdapter(uint32_t power_preference) {
+  webgpu::cmds::RequestAdapter* c = GetCmdSpace<webgpu::cmds::RequestAdapter>();
+  if (c) {
+    c->Init(power_preference);
+  }
+}
+
 #endif  // GPU_COMMAND_BUFFER_CLIENT_WEBGPU_CMD_HELPER_AUTOGEN_H_

gpu/command_buffer/client/webgpu_implementation.cc

@@ -344,5 +344,12 @@ ReservedTexture WebGPUImplementation::ReserveTexture(DawnDevice device) {
 #endif
 }
 
+void WebGPUImplementation::RequestAdapter(PowerPreference power_preference) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] wgRequestAdapter("
+                     << static_cast<uint32_t>(power_preference) << ")");
+  helper_->RequestAdapter(static_cast<uint32_t>(power_preference));
+}
+
 }  // namespace webgpu
 }  // namespace gpu

gpu/command_buffer/client/webgpu_implementation_autogen.h

@@ -22,4 +22,7 @@ void AssociateMailbox(GLuint device_id,
 
 void DissociateMailbox(GLuint texture_id, GLuint texture_generation) override;
 
+void RequestAdapter(PowerPreference power_preference =
+                        PowerPreference::kHighPerformance) override;
+
 #endif  // GPU_COMMAND_BUFFER_CLIENT_WEBGPU_IMPLEMENTATION_AUTOGEN_H_

gpu/command_buffer/client/webgpu_implementation_unittest_autogen.h

@@ -39,4 +39,15 @@ TEST_F(WebGPUImplementationTest, DissociateMailbox) {
   gl_->DissociateMailbox(1, 2);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
+
+TEST_F(WebGPUImplementationTest, RequestAdapter) {
+  struct Cmds {
+    cmds::RequestAdapter cmd;
+  };
+  Cmds expected;
+  expected.cmd.Init(1);
+
+  gl_->RequestAdapter(PowerPreference::kHighPerformance);
+  EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
+}
 #endif  // GPU_COMMAND_BUFFER_CLIENT_WEBGPU_IMPLEMENTATION_UNITTEST_AUTOGEN_H_

gpu/command_buffer/client/webgpu_interface.h

@@ -8,6 +8,7 @@
 #include <dawn/dawn.h>
 
 #include "gpu/command_buffer/client/interface_base.h"
+#include "gpu/command_buffer/common/webgpu_cmd_enums.h"
 
 namespace gpu {
 namespace webgpu {

gpu/command_buffer/client/webgpu_interface_autogen.h

@@ -21,4 +21,6 @@ virtual void AssociateMailbox(GLuint device_id,
                               const GLbyte* mailbox) = 0;
 virtual void DissociateMailbox(GLuint texture_id,
                                GLuint texture_generation) = 0;
+virtual void RequestAdapter(
+    PowerPreference power_preference = PowerPreference::kHighPerformance) = 0;
 #endif  // GPU_COMMAND_BUFFER_CLIENT_WEBGPU_INTERFACE_AUTOGEN_H_

gpu/command_buffer/client/webgpu_interface_stub_autogen.h

@@ -19,4 +19,5 @@ void AssociateMailbox(GLuint device_id,
                       GLuint usage,
                       const GLbyte* mailbox) override;
 void DissociateMailbox(GLuint texture_id, GLuint texture_generation) override;
+void RequestAdapter(PowerPreference power_preference) override;
 #endif  // GPU_COMMAND_BUFFER_CLIENT_WEBGPU_INTERFACE_STUB_AUTOGEN_H_

gpu/command_buffer/client/webgpu_interface_stub_impl_autogen.h

@@ -20,4 +20,6 @@ void WebGPUInterfaceStub::AssociateMailbox(GLuint /* device_id */,
                                            const GLbyte* /* mailbox */) {}
 void WebGPUInterfaceStub::DissociateMailbox(GLuint /* texture_id */,
                                             GLuint /* texture_generation */) {}
+void WebGPUInterfaceStub::RequestAdapter(
+    PowerPreference /* power_preference */) {}
 #endif  // GPU_COMMAND_BUFFER_CLIENT_WEBGPU_INTERFACE_STUB_IMPL_AUTOGEN_H_

gpu/command_buffer/common/BUILD.gn

@@ -178,6 +178,7 @@ source_set("webgpu_sources") {
 
   sources = [
     "dawn_memory_transfer_handle.h",
+    "webgpu_cmd_enums.h",
     "webgpu_cmd_format.cc",
     "webgpu_cmd_format.h",
     "webgpu_cmd_format_autogen.h",

gpu/command_buffer/common/webgpu_cmd_enums.h

+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GPU_COMMAND_BUFFER_COMMON_WEBGPU_CMD_ENUMS_H_
+#define GPU_COMMAND_BUFFER_COMMON_WEBGPU_CMD_ENUMS_H_
+
+namespace gpu {
+namespace webgpu {
+
+enum class PowerPreference : uint32_t {
+  kLowPower,
+  kHighPerformance,
+  kNumPowerPreferences
+};
+
+// These numbers must not change
+static_assert(static_cast<int>(PowerPreference::kLowPower) == 0,
+              "kLowPower should equal 0");
+static_assert(static_cast<int>(PowerPreference::kHighPerformance) == 1,
+              "kHighPerformance should equal 1");
+
+}  // namespace webgpu
+}  // namespace gpu
+#endif  // GPU_COMMAND_BUFFER_COMMON_WEBGPU_CMD_ENUMS_H_

gpu/command_buffer/common/webgpu_cmd_format_autogen.h

@@ -164,4 +164,37 @@ static_assert(offsetof(DissociateMailbox, texture_id) == 4,
 static_assert(offsetof(DissociateMailbox, texture_generation) == 8,
               "offset of DissociateMailbox texture_generation should be 8");
 
+struct RequestAdapter {
+  typedef RequestAdapter ValueType;
+  static const CommandId kCmdId = kRequestAdapter;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(uint32_t _power_preference) {
+    SetHeader();
+    power_preference = _power_preference;
+  }
+
+  void* Set(void* cmd, uint32_t _power_preference) {
+    static_cast<ValueType*>(cmd)->Init(_power_preference);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t power_preference;
+};
+
+static_assert(sizeof(RequestAdapter) == 8,
+              "size of RequestAdapter should be 8");
+static_assert(offsetof(RequestAdapter, header) == 0,
+              "offset of RequestAdapter header should be 0");
+static_assert(offsetof(RequestAdapter, power_preference) == 4,
+              "offset of RequestAdapter power_preference should be 4");
+
 #endif  // GPU_COMMAND_BUFFER_COMMON_WEBGPU_CMD_FORMAT_AUTOGEN_H_

gpu/command_buffer/common/webgpu_cmd_format_test_autogen.h

@@ -79,4 +79,14 @@ TEST_F(WebGPUFormatTest, DissociateMailbox) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
+TEST_F(WebGPUFormatTest, RequestAdapter) {
+  cmds::RequestAdapter& cmd = *GetBufferAs<cmds::RequestAdapter>();
+  void* next_cmd = cmd.Set(&cmd, static_cast<uint32_t>(11));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::RequestAdapter::kCmdId),
+            cmd.header.command);
+  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
+  EXPECT_EQ(static_cast<uint32_t>(11), cmd.power_preference);
+  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
+}
+
 #endif  // GPU_COMMAND_BUFFER_COMMON_WEBGPU_CMD_FORMAT_TEST_AUTOGEN_H_

gpu/command_buffer/common/webgpu_cmd_ids_autogen.h

@@ -14,7 +14,8 @@
 #define WEBGPU_COMMAND_LIST(OP)           \
   OP(DawnCommands)              /* 256 */ \
   OP(AssociateMailboxImmediate) /* 257 */ \
-  OP(DissociateMailbox)         /* 258 */
+  OP(DissociateMailbox)         /* 258 */ \
+  OP(RequestAdapter)            /* 259 */
 
 enum CommandId {
   kOneBeforeStartPoint =

gpu/command_buffer/service/webgpu_cmd_validation.h

@@ -9,11 +9,58 @@
 
 #include <algorithm>
 #include <vector>
+#include "base/stl_util.h"
+#include "gpu/command_buffer/common/webgpu_cmd_enums.h"
 #include "gpu/command_buffer/common/webgpu_cmd_format.h"
+#include "gpu/command_buffer/service/gles2_cmd_validation.h"
 
 namespace gpu {
 namespace webgpu {
 
+// ValueValidator returns true if a value is valid.
+template <typename T>
+class ValueValidator {
+ public:
+  ValueValidator() = default;
+
+  ValueValidator(const T* valid_values, int num_values) {
+    AddValues(valid_values, num_values);
+  }
+
+  void AddValue(const T value) {
+    if (!IsValid(value)) {
+      valid_values_.push_back(value);
+    }
+  }
+
+  void AddValues(const T* valid_values, int num_values) {
+    for (int ii = 0; ii < num_values; ++ii) {
+      AddValue(valid_values[ii]);
+    }
+  }
+
+  void RemoveValues(const T* invalid_values, int num_values) {
+    for (int ii = 0; ii < num_values; ++ii) {
+      auto iter = std::find(valid_values_.begin(), valid_values_.end(),
+                            invalid_values[ii]);
+      if (iter != valid_values_.end()) {
+        valid_values_.erase(iter);
+        DCHECK(!IsValid(invalid_values[ii]));
+      }
+    }
+  }
+
+  bool IsValid(const T value) const {
+    return std::find(valid_values_.begin(), valid_values_.end(), value) !=
+           valid_values_.end();
+  }
+
+  const std::vector<T>& GetValues() const { return valid_values_; }
+
+ private:
+  std::vector<T> valid_values_;
+};
+
 struct Validators {
   Validators();
 

gpu/command_buffer/service/webgpu_cmd_validation_autogen.h

@@ -11,4 +11,6 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_WEBGPU_CMD_VALIDATION_AUTOGEN_H_
 #define GPU_COMMAND_BUFFER_SERVICE_WEBGPU_CMD_VALIDATION_AUTOGEN_H_
 
+ValueValidator<PowerPreference> power_preference;
+
 #endif  // GPU_COMMAND_BUFFER_SERVICE_WEBGPU_CMD_VALIDATION_AUTOGEN_H_

gpu/command_buffer/service/webgpu_cmd_validation_implementation_autogen.h

@@ -11,6 +11,13 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_WEBGPU_CMD_VALIDATION_IMPLEMENTATION_AUTOGEN_H_
 #define GPU_COMMAND_BUFFER_SERVICE_WEBGPU_CMD_VALIDATION_IMPLEMENTATION_AUTOGEN_H_
 
-Validators::Validators() {}
+static const PowerPreference valid_power_preference_table[] = {
+    PowerPreference::kHighPerformance,
+    PowerPreference::kLowPower,
+};
+
+Validators::Validators()
+    : power_preference(valid_power_preference_table,
+                       base::size(valid_power_preference_table)) {}
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_WEBGPU_CMD_VALIDATION_IMPLEMENTATION_AUTOGEN_H_

gpu/command_buffer/service/webgpu_decoder_impl.cc

@@ -17,6 +17,7 @@
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/mailbox.h"
+#include "gpu/command_buffer/common/webgpu_cmd_enums.h"
 #include "gpu/command_buffer/common/webgpu_cmd_format.h"
 #include "gpu/command_buffer/common/webgpu_cmd_ids.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
@@ -99,6 +100,19 @@ bool WireServerCommandSerializer::Flush() {
   return true;
 }
 
+dawn_native::DeviceType PowerPreferenceToDawnDeviceType(
+    PowerPreference power_preference) {
+  switch (power_preference) {
+    case PowerPreference::kLowPower:
+      return dawn_native::DeviceType::IntegratedGPU;
+    case PowerPreference::kHighPerformance:
+      return dawn_native::DeviceType::DiscreteGPU;
+    default:
+      NOTREACHED();
+      return dawn_native::DeviceType::CPU;
+  }
+}
+
 }  // namespace
 
 class WebGPUDecoderImpl final : public WebGPUDecoder {
@@ -328,7 +342,12 @@ class WebGPUDecoderImpl final : public WebGPUDecoder {
   // only if not returning an error.
   error::Error current_decoder_error_ = error::kNoError;
 
-  DawnDevice CreateDefaultDevice();
+  void DiscoverAdapters();
+
+  dawn_native::Adapter GetPreferredAdapter(
+      PowerPreference power_preference) const;
+
+  error::Error InitDawnDeviceAndSetWireServer(dawn_native::Adapter* adapter);
 
   std::unique_ptr<SharedImageRepresentationFactory>
       shared_image_representation_factory_;
@@ -342,6 +361,7 @@ class WebGPUDecoderImpl final : public WebGPUDecoder {
   std::unique_ptr<WireServerCommandSerializer> wire_serializer_;
   std::unique_ptr<DawnServiceMemoryTransferService> memory_transfer_service_;
   std::unique_ptr<dawn_native::Instance> dawn_instance_;
+  std::vector<dawn_native::Adapter> dawn_adapters_;
   DawnProcTable dawn_procs_;
   DawnDevice dawn_device_ = nullptr;
   std::unique_ptr<dawn_wire::WireServer> wire_server_;
@@ -402,9 +422,17 @@ WebGPUDecoderImpl::~WebGPUDecoderImpl() {
 }
 
 ContextResult WebGPUDecoderImpl::Initialize() {
-  dawn_device_ = CreateDefaultDevice();
+  DiscoverAdapters();
+  return ContextResult::kSuccess;
+}
+
+error::Error WebGPUDecoderImpl::InitDawnDeviceAndSetWireServer(
+    dawn_native::Adapter* adapter) {
+  DCHECK(adapter != nullptr && (*adapter));
+
+  dawn_device_ = adapter->CreateDevice();
   if (dawn_device_ == nullptr) {
-    return ContextResult::kFatalFailure;
+    return error::kLostContext;
   }
 
   dawn_wire::WireServerDescriptor descriptor = {};
@@ -415,10 +443,13 @@ ContextResult WebGPUDecoderImpl::Initialize() {
 
   wire_server_ = std::make_unique<dawn_wire::WireServer>(descriptor);
 
-  return ContextResult::kSuccess;
+  return error::kNoError;
 }
 
-DawnDevice WebGPUDecoderImpl::CreateDefaultDevice() {
+void WebGPUDecoderImpl::DiscoverAdapters() {
+  dawn_instance_->DiscoverDefaultAdapters();
+  std::vector<dawn_native::Adapter> adapters = dawn_instance_->GetAdapters();
+  for (const dawn_native::Adapter& adapter : adapters) {
 #if defined(OS_WIN)
   // On Windows 10, we pick D3D12 backend because the rest of Chromium renders
   // with D3D11. By the same token, we pick the first adapter because ANGLE also
@@ -427,57 +458,63 @@ DawnDevice WebGPUDecoderImpl::CreateDefaultDevice() {
   // decide to handle multiple adapters, code on the Chromium side will need to
   // change to do appropriate cross adapter copying to make this happen, either
   // manually or by using DirectComposition.
-  dawn_instance_->DiscoverDefaultAdapters();
-  const std::vector<dawn_native::Adapter> adapters =
-      dawn_instance_->GetAdapters();
-
-  for (dawn_native::Adapter adapter : adapters) {
     if (adapter.GetBackendType() == dawn_native::BackendType::D3D12) {
-      return adapter.CreateDevice();
+#else
+    if (adapter.GetBackendType() != dawn_native::BackendType::Null &&
+        adapter.GetBackendType() != dawn_native::BackendType::OpenGL) {
+#endif
+      dawn_adapters_.push_back(adapter);
     }
   }
-  return nullptr;
-#else
-  dawn_instance_->DiscoverDefaultAdapters();
-  std::vector<dawn_native::Adapter> adapters = dawn_instance_->GetAdapters();
+}
+
+dawn_native::Adapter WebGPUDecoderImpl::GetPreferredAdapter(
+    PowerPreference power_preference) const {
+  dawn_native::DeviceType preferred_device_type =
+      PowerPreferenceToDawnDeviceType(power_preference);
 
+  dawn_native::Adapter discrete_gpu_adapter = {};
   dawn_native::Adapter integrated_gpu_adapter = {};
   dawn_native::Adapter cpu_adapter = {};
   dawn_native::Adapter unknown_adapter = {};
 
-  for (dawn_native::Adapter adapter : adapters) {
-    if (adapter.GetBackendType() != dawn_native::BackendType::Null &&
-        adapter.GetBackendType() != dawn_native::BackendType::OpenGL) {
-      switch (adapter.GetDeviceType()) {
-        case dawn_native::DeviceType::DiscreteGPU:
-          // For now, we always prefer the discrete GPU
-          return adapter.CreateDevice();
-        case dawn_native::DeviceType::IntegratedGPU:
-          integrated_gpu_adapter = adapter;
-          break;
-        case dawn_native::DeviceType::CPU:
-          cpu_adapter = adapter;
-          break;
-        case dawn_native::DeviceType::Unknown:
-          unknown_adapter = adapter;
-          break;
-        default:
-          NOTREACHED();
-          break;
-      }
+  for (const dawn_native::Adapter& adapter : dawn_adapters_) {
+    if (adapter.GetDeviceType() == preferred_device_type) {
+      return adapter;
+    }
+    switch (adapter.GetDeviceType()) {
+      case dawn_native::DeviceType::DiscreteGPU:
+        discrete_gpu_adapter = adapter;
+        break;
+      case dawn_native::DeviceType::IntegratedGPU:
+        integrated_gpu_adapter = adapter;
+        break;
+      case dawn_native::DeviceType::CPU:
+        cpu_adapter = adapter;
+        break;
+      case dawn_native::DeviceType::Unknown:
+        unknown_adapter = adapter;
+        break;
+      default:
+        NOTREACHED();
+        break;
     }
   }
+
+  // For now, we always prefer the discrete GPU
+  if (discrete_gpu_adapter) {
+    return discrete_gpu_adapter;
+  }
   if (integrated_gpu_adapter) {
-    return integrated_gpu_adapter.CreateDevice();
+    return integrated_gpu_adapter;
   }
   if (cpu_adapter) {
-    return cpu_adapter.CreateDevice();
+    return cpu_adapter;
   }
   if (unknown_adapter) {
-    return unknown_adapter.CreateDevice();
+    return unknown_adapter;
   }
-  return nullptr;
-#endif
+  return dawn_native::Adapter();
 }
 
 const char* WebGPUDecoderImpl::GetCommandName(unsigned int command_id) const {
@@ -553,6 +590,24 @@ error::Error WebGPUDecoderImpl::DoCommands(unsigned int num_commands,
   return result;
 }
 
+error::Error WebGPUDecoderImpl::HandleRequestAdapter(
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
+  const volatile webgpu::cmds::RequestAdapter& c =
+      *static_cast<const volatile webgpu::cmds::RequestAdapter*>(cmd_data);
+
+  PowerPreference power_preference =
+      static_cast<PowerPreference>(c.power_preference);
+  dawn_native::Adapter requested_adapter =
+      GetPreferredAdapter(power_preference);
+  if (!requested_adapter) {
+    return error::kLostContext;
+  }
+
+  // TODO(jiawei.shao@intel.com): support creating device with device descriptor
+  return InitDawnDeviceAndSetWireServer(&requested_adapter);
+}
+
 error::Error WebGPUDecoderImpl::HandleDawnCommands(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {

gpu/command_buffer/service/webgpu_decoder_unittest.cc

@@ -6,6 +6,7 @@
 
 #include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/common/shared_image_usage.h"
+#include "gpu/command_buffer/common/webgpu_cmd_enums.h"
 #include "gpu/command_buffer/common/webgpu_cmd_format.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/decoder_client.h"
@@ -46,6 +47,15 @@ class WebGPUDecoderTest : public ::testing::Test {
                                          &outputter_));
     if (decoder_->Initialize() != ContextResult::kSuccess) {
       decoder_ = nullptr;
+    } else {
+      cmds::RequestAdapter requestAdapterCmd;
+      requestAdapterCmd.Init(
+          static_cast<uint32_t>(webgpu::PowerPreference::kHighPerformance));
+      if (ExecuteCmd(requestAdapterCmd) == error::kLostContext) {
+        decoder_ = nullptr;
+      } else {
+        ASSERT_EQ(error::kNoError, ExecuteCmd(requestAdapterCmd));
+      }
     }
 
     factory_ = std::make_unique<SharedImageFactory>(

gpu/command_buffer/tests/webgpu_test.cc

@@ -78,6 +78,8 @@ void WebGPUTest::Initialize(const Options& options) {
     return;
   }
 
+  webgpu()->RequestAdapter(webgpu::PowerPreference::kHighPerformance);
+
   DawnProcTable procs = webgpu()->GetProcs();
   dawnSetProcs(&procs);
 }

gpu/command_buffer/webgpu_cmd_buffer_functions.txt

@@ -9,3 +9,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 (EnumClassPowerPreference power_preference = PowerPreference::kHighPerformance);

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

@@ -65,16 +65,14 @@ ScriptPromise GPU::requestAdapter(ScriptState* script_state,
   auto* resolver = MakeGarbageCollected<ScriptPromiseResolver>(script_state);
   ScriptPromise promise = resolver->Promise();
 
-  if (options->powerPreference()) {
-    ExecutionContext::From(script_state)
-        ->AddConsoleMessage(ConsoleMessage::Create(
-            mojom::ConsoleMessageSource::kJavaScript,
-            mojom::ConsoleMessageLevel::kWarning,
-            "The powerPreference option is not implemented yet."));
+  // For now we choose kHighPerformance by default.
+  gpu::webgpu::PowerPreference power_preference =
+      gpu::webgpu::PowerPreference::kHighPerformance;
+  if (options->powerPreference() == "low-power") {
+    power_preference = gpu::webgpu::PowerPreference::kLowPower;
   }
-
-  // TODO(enga): Request the adapter from the WebGPUInterface.
-  GPUAdapter* adapter = GPUAdapter::Create("Default", dawn_control_client_);
+  GPUAdapter* adapter =
+      GPUAdapter::Create("Default", power_preference, dawn_control_client_);
 
   resolver->Resolve(adapter);
   return promise;

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

@@ -6,20 +6,26 @@
 
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
 #include "third_party/blink/renderer/modules/webgpu/gpu_device.h"
+#include "third_party/blink/renderer/modules/webgpu/gpu_request_adapter_options.h"
 
 namespace blink {
 
 // static
 GPUAdapter* GPUAdapter::Create(
     const String& name,
+    gpu::webgpu::PowerPreference power_preference,
     scoped_refptr<DawnControlClientHolder> dawn_control_client) {
-  return MakeGarbageCollected<GPUAdapter>(name, std::move(dawn_control_client));
+  return MakeGarbageCollected<GPUAdapter>(name, power_preference,
+                                          std::move(dawn_control_client));
 }
 
 GPUAdapter::GPUAdapter(
     const String& name,
+    gpu::webgpu::PowerPreference power_preference,
     scoped_refptr<DawnControlClientHolder> dawn_control_client)
-    : DawnObjectBase(std::move(dawn_control_client)), name_(name) {}
+    : DawnObjectBase(dawn_control_client), name_(name) {
+  dawn_control_client->GetInterface()->RequestAdapter(power_preference);
+}
 
 const String& GPUAdapter::name() const {
   return name_;

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

@@ -6,6 +6,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_WEBGPU_GPU_ADAPTER_H_
 
 #include "base/memory/scoped_refptr.h"
+#include "gpu/command_buffer/client/webgpu_interface.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
 #include "third_party/blink/renderer/core/execution_context/execution_context.h"
 #include "third_party/blink/renderer/modules/webgpu/dawn_object.h"
@@ -22,8 +23,10 @@ class GPUAdapter final : public ScriptWrappable, public DawnObjectBase {
  public:
   static GPUAdapter* Create(
       const String& name,
+      gpu::webgpu::PowerPreference power_preference,
       scoped_refptr<DawnControlClientHolder> dawn_control_client);
   GPUAdapter(const String& name,
+             gpu::webgpu::PowerPreference power_preference,
              scoped_refptr<DawnControlClientHolder> dawn_control_client);
 
   const String& name() const;

third_party/blink/tools/blinkpy/presubmit/audit_non_blink_usage.py

@@ -736,6 +736,7 @@ _CONFIG = [
         # The WebGPU Blink module needs access to the WebGPU control
         # command buffer interface.
         'allowed': [
+            'gpu::webgpu::PowerPreference',
             'gpu::webgpu::WebGPUInterface',
         ],
     },