chromeos: renames GpuSupport to GpuInterfaceProvider

And updates the functions to better reflect what it is suppose to do. There was
a race conditions with how the code was before. In particular, because
access to content has to be on the io-thread care must be taken during
destruction. Creation of the interfaces happens on the io thread, which means
destruction of the object supplied to AddInterface() has to happen on the
io-thread. I separated out the parts that happen on the io thread into a
refcounted thread safe that is destroyed on the io thread.

BUG=837686
TEST=covered by tests

Change-Id: Ia3dce4894a3cf4b7a08cd5a9c4d1fae674d7e7c5
Reviewed-on: https://chromium-review.googlesource.com/1105611Reviewed-by: Xiyuan Xia <xiyuan@chromium.org>
Commit-Queue: Scott Violet <sky@chromium.org>
Cr-Commit-Position: refs/heads/master@{#568469}

ash/BUILD.gn

@@ -1436,8 +1436,8 @@ component("ash") {
 component("ash_with_content") {
   sources = [
     "content/ash_with_content_export.h",
-    "content/content_gpu_support.cc",
-    "content/content_gpu_support.h",
+    "content/content_gpu_interface_provider.cc",
+    "content/content_gpu_interface_provider.h",
     "content/keyboard_overlay/keyboard_overlay_delegate.cc",
     "content/keyboard_overlay/keyboard_overlay_delegate.h",
     "content/keyboard_overlay/keyboard_overlay_view.cc",
@@ -1461,6 +1461,8 @@ component("ash_with_content") {
     "//content/public/browser",
     "//gpu/config",
     "//ipc",
+    "//mojo/public/cpp/bindings",
+    "//services/ui/public/interfaces",
     "//skia",
     "//ui/aura",
     "//ui/base",

ash/content/DEPS

 specific_include_rules = {
-  "content_gpu_support.*": [
+  "content_gpu_interface_provider.*": [
+    "+components/discardable_memory/public/interfaces",
     "+content/public/browser",
   ],
   "screen_orientation_delegate_chromeos.cc": [

ash/content/content_gpu_interface_provider.cc

+// Copyright 2018 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.
+
+#include "ash/content/content_gpu_interface_provider.h"
+
+#include "base/containers/unique_ptr_adapters.h"
+#include "base/memory/ref_counted.h"
+#include "components/discardable_memory/public/interfaces/discardable_shared_memory_manager.mojom.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/gpu_client.h"
+#include "content/public/browser/gpu_service_registry.h"
+#include "services/ui/public/interfaces/gpu.mojom.h"
+
+namespace ash {
+
+// InterfaceBinderImpl handles the actual binding. The binding (and destruction
+// of this object) has to happen on the io-thread.
+class ContentGpuInterfaceProvider::InterfaceBinderImpl
+    : public base::RefCountedThreadSafe<
+          InterfaceBinderImpl,
+          content::BrowserThread::DeleteOnIOThread> {
+ public:
+  InterfaceBinderImpl() = default;
+
+  void BindGpuRequestOnGpuTaskRunner(ui::mojom::GpuRequest request) {
+    auto gpu_client = content::GpuClient::Create(
+        std::move(request),
+        base::BindOnce(&InterfaceBinderImpl::OnGpuClientConnectionError, this));
+    gpu_clients_.push_back(std::move(gpu_client));
+  }
+
+  void BindDiscardableSharedMemoryManagerOnGpuTaskRunner(
+      discardable_memory::mojom::DiscardableSharedMemoryManagerRequest
+          request) {
+    content::BindInterfaceInGpuProcess(std::move(request));
+  }
+
+ private:
+  friend struct content::BrowserThread::DeleteOnThread<
+      content::BrowserThread::IO>;
+  friend class base::DeleteHelper<InterfaceBinderImpl>;
+
+  ~InterfaceBinderImpl() = default;
+
+  void OnGpuClientConnectionError(content::GpuClient* client) {
+    base::EraseIf(
+        gpu_clients_,
+        base::UniquePtrMatcher<content::GpuClient,
+                               content::BrowserThread::DeleteOnIOThread>(
+            client));
+  }
+
+  std::vector<std::unique_ptr<content::GpuClient,
+                              content::BrowserThread::DeleteOnIOThread>>
+      gpu_clients_;
+
+  DISALLOW_COPY_AND_ASSIGN(InterfaceBinderImpl);
+};
+
+ContentGpuInterfaceProvider::ContentGpuInterfaceProvider()
+    : interface_binder_impl_(base::MakeRefCounted<InterfaceBinderImpl>()) {}
+
+ContentGpuInterfaceProvider::~ContentGpuInterfaceProvider() = default;
+
+void ContentGpuInterfaceProvider::RegisterGpuInterfaces(
+    service_manager::BinderRegistry* registry) {
+  scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner =
+      content::BrowserThread::GetTaskRunnerForThread(
+          content::BrowserThread::IO);
+  registry->AddInterface(
+      base::BindRepeating(&InterfaceBinderImpl::
+                              BindDiscardableSharedMemoryManagerOnGpuTaskRunner,
+                          interface_binder_impl_),
+      gpu_task_runner);
+  registry->AddInterface(
+      base::BindRepeating(&InterfaceBinderImpl::BindGpuRequestOnGpuTaskRunner,
+                          interface_binder_impl_),
+      gpu_task_runner);
+}
+
+}  // namespace ash

ash/content/content_gpu_interface_provider.h

+// Copyright 2018 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 ASH_CONTENT_CONTENT_GPU_INTERFACE_PROVIDER_H_
+#define ASH_CONTENT_CONTENT_GPU_INTERFACE_PROVIDER_H_
+
+#include <memory>
+#include <vector>
+
+#include "ash/content/ash_with_content_export.h"
+#include "base/macros.h"
+#include "base/memory/scoped_refptr.h"
+#include "services/ui/ws2/gpu_interface_provider.h"
+
+namespace ash {
+
+// An implementation of GpuInterfaceProvider that forwards to the Gpu
+// implementation in content.
+class ASH_WITH_CONTENT_EXPORT ContentGpuInterfaceProvider
+    : public ui::ws2::GpuInterfaceProvider {
+ public:
+  ContentGpuInterfaceProvider();
+  ~ContentGpuInterfaceProvider() override;
+
+  // ui::ws2::GpuInterfaceProvider:
+  void RegisterGpuInterfaces(
+      service_manager::BinderRegistry* registry) override;
+
+ private:
+  class InterfaceBinderImpl;
+
+  scoped_refptr<InterfaceBinderImpl> interface_binder_impl_;
+
+  DISALLOW_COPY_AND_ASSIGN(ContentGpuInterfaceProvider);
+};
+
+}  // namespace ash
+
+#endif  // ASH_CONTENT_CONTENT_GPU_INTERFACE_PROVIDER_H_

ash/content/content_gpu_support.cc

-// Copyright 2018 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.
-
-#include "ash/content/content_gpu_support.h"
-
-#include "base/containers/unique_ptr_adapters.h"
-#include "content/public/browser/gpu_client.h"
-#include "content/public/browser/gpu_service_registry.h"
-
-namespace ash {
-
-ContentGpuSupport::ContentGpuSupport() = default;
-
-ContentGpuSupport::~ContentGpuSupport() = default;
-
-scoped_refptr<base::SingleThreadTaskRunner>
-ContentGpuSupport::GetGpuTaskRunner() {
-  return content::BrowserThread::GetTaskRunnerForThread(
-      content::BrowserThread::IO);
-}
-
-void ContentGpuSupport::BindDiscardableSharedMemoryManagerOnGpuTaskRunner(
-    discardable_memory::mojom::DiscardableSharedMemoryManagerRequest request) {
-  content::BindInterfaceInGpuProcess(std::move(request));
-}
-
-void ContentGpuSupport::BindGpuRequestOnGpuTaskRunner(
-    ui::mojom::GpuRequest request) {
-  auto gpu_client = content::GpuClient::Create(
-      std::move(request),
-      base::BindOnce(&ContentGpuSupport::OnGpuClientConnectionError,
-                     base::Unretained(this)));
-  gpu_clients_.push_back(std::move(gpu_client));
-}
-
-void ContentGpuSupport::OnGpuClientConnectionError(content::GpuClient* client) {
-  base::EraseIf(
-      gpu_clients_,
-      base::UniquePtrMatcher<content::GpuClient,
-                             content::BrowserThread::DeleteOnIOThread>(client));
-}
-
-}  // namespace ash

ash/content/content_gpu_support.h

-// Copyright 2018 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 ASH_CONTENT_CONTENT_GPU_SUPPORT_H_
-#define ASH_CONTENT_CONTENT_GPU_SUPPORT_H_
-
-#include <memory>
-#include <vector>
-
-#include "ash/content/ash_with_content_export.h"
-#include "base/macros.h"
-#include "content/public/browser/browser_thread.h"
-#include "services/ui/ws2/gpu_support.h"
-
-namespace content {
-class GpuClient;
-}
-
-namespace ash {
-
-// An implementation of GpuSupport that forwards to the Gpu implementation in
-// content.
-class ASH_WITH_CONTENT_EXPORT ContentGpuSupport : public ui::ws2::GpuSupport {
- public:
-  ContentGpuSupport();
-  ~ContentGpuSupport() override;
-
-  // ui::ws2::GpuSupport:
-  scoped_refptr<base::SingleThreadTaskRunner> GetGpuTaskRunner() override;
-  void BindDiscardableSharedMemoryManagerOnGpuTaskRunner(
-      discardable_memory::mojom::DiscardableSharedMemoryManagerRequest request)
-      override;
-  void BindGpuRequestOnGpuTaskRunner(ui::mojom::GpuRequest request) override;
-
- private:
-  void OnGpuClientConnectionError(content::GpuClient* client);
-
-  std::vector<std::unique_ptr<content::GpuClient,
-                              content::BrowserThread::DeleteOnIOThread>>
-      gpu_clients_;
-
-  DISALLOW_COPY_AND_ASSIGN(ContentGpuSupport);
-};
-
-}  // namespace ash
-
-#endif  // ASH_CONTENT_CONTENT_GPU_SUPPORT_H_

ash/shell.cc

@@ -177,7 +177,7 @@
 #include "services/preferences/public/mojom/preferences.mojom.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/ui/public/interfaces/constants.mojom.h"
-#include "services/ui/ws2/gpu_support.h"
+#include "services/ui/ws2/gpu_interface_provider.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/layout_manager.h"
@@ -280,7 +280,7 @@ Shell* Shell::CreateInstance(ShellInitParams init_params) {
   instance_->Init(init_params.context_factory,
                   init_params.context_factory_private,
                   std::move(init_params.initial_display_prefs),
-                  std::move(init_params.gpu_support));
+                  std::move(init_params.gpu_interface_provider));
   return instance_;
 }
 
@@ -955,10 +955,11 @@ Shell::~Shell() {
   instance_ = nullptr;
 }
 
-void Shell::Init(ui::ContextFactory* context_factory,
-                 ui::ContextFactoryPrivate* context_factory_private,
-                 std::unique_ptr<base::Value> initial_display_prefs,
-                 std::unique_ptr<ui::ws2::GpuSupport> gpu_support) {
+void Shell::Init(
+    ui::ContextFactory* context_factory,
+    ui::ContextFactoryPrivate* context_factory_private,
+    std::unique_ptr<base::Value> initial_display_prefs,
+    std::unique_ptr<ui::ws2::GpuInterfaceProvider> gpu_interface_provider) {
   const Config config = shell_port_->GetAshConfig();
 
   // This creates the MessageCenter object which is used by some other objects
@@ -1298,7 +1299,7 @@ void Shell::Init(ui::ContextFactory* context_factory,
 
   if (config != Config::MASH) {
     window_service_owner_ =
-        std::make_unique<WindowServiceOwner>(std::move(gpu_support));
+        std::make_unique<WindowServiceOwner>(std::move(gpu_interface_provider));
     ime_focus_handler_ = std::make_unique<ImeFocusHandler>(
         focus_controller(), window_tree_host_manager_->input_method());
   }

ash/shell.h

@@ -62,7 +62,7 @@ class ContextFactoryPrivate;
 class UserActivityDetector;
 class UserActivityPowerManagerNotifier;
 namespace ws2 {
-class GpuSupport;
+class GpuInterfaceProvider;
 }
 }  // namespace ui
 
@@ -675,10 +675,11 @@ class ASH_EXPORT Shell : public SessionObserver,
         std::unique_ptr<ShellPort> shell_port);
   ~Shell() override;
 
-  void Init(ui::ContextFactory* context_factory,
-            ui::ContextFactoryPrivate* context_factory_private,
-            std::unique_ptr<base::Value> initial_display_prefs,
-            std::unique_ptr<ui::ws2::GpuSupport> gpu_support);
+  void Init(
+      ui::ContextFactory* context_factory,
+      ui::ContextFactoryPrivate* context_factory_private,
+      std::unique_ptr<base::Value> initial_display_prefs,
+      std::unique_ptr<ui::ws2::GpuInterfaceProvider> gpu_interface_provider);
 
   // Initializes the display manager and related components.
   void InitializeDisplayManager();

ash/shell/content/client/shell_browser_main_parts.cc

@@ -10,7 +10,7 @@
 #include "ash/components/quick_launch/public/mojom/constants.mojom.h"
 #include "ash/components/shortcut_viewer/public/mojom/shortcut_viewer.mojom.h"
 #include "ash/components/tap_visualizer/public/mojom/constants.mojom.h"
-#include "ash/content/content_gpu_support.h"
+#include "ash/content/content_gpu_interface_provider.h"
 #include "ash/content/shell_content_state.h"
 #include "ash/login_status.h"
 #include "ash/public/cpp/ash_features.h"
@@ -97,7 +97,8 @@ void ShellBrowserMainParts::PreMainMessageLoopRun() {
   init_params.delegate = std::make_unique<ash::shell::ShellDelegateImpl>();
   init_params.context_factory = content::GetContextFactory();
   init_params.context_factory_private = content::GetContextFactoryPrivate();
-  init_params.gpu_support = std::make_unique<ContentGpuSupport>();
+  init_params.gpu_interface_provider =
+      std::make_unique<ContentGpuInterfaceProvider>();
   ash::Shell::CreateInstance(std::move(init_params));
 
   // Initialize session controller client and create fake user sessions. The

ash/shell_init_params.cc

@@ -6,7 +6,7 @@
 
 #include "ash/shell_delegate.h"
 #include "ash/shell_port.h"
-#include "services/ui/ws2/gpu_support.h"
+#include "services/ui/ws2/gpu_interface_provider.h"
 
 namespace ash {
 

ash/shell_init_params.h

@@ -17,7 +17,7 @@ namespace ui {
 class ContextFactory;
 class ContextFactoryPrivate;
 namespace ws2 {
-class GpuSupport;
+class GpuInterfaceProvider;
 }
 }
 
@@ -39,9 +39,9 @@ struct ASH_EXPORT ShellInitParams {
   // ShellObserver::OnLocalStatePrefServiceInitialized is called.
   std::unique_ptr<base::Value> initial_display_prefs;
 
-  // Allows gpu-support to be injected while avoiding direct content
+  // Allows gpu interfaces to be injected while avoiding direct content
   // dependencies.
-  std::unique_ptr<ui::ws2::GpuSupport> gpu_support;
+  std::unique_ptr<ui::ws2::GpuInterfaceProvider> gpu_interface_provider;
 };
 
 }  // namespace ash

ash/ws/window_service_owner.cc

@@ -9,15 +9,15 @@
 #include "ash/wm/non_client_frame_controller.h"
 #include "ash/ws/window_service_delegate_impl.h"
 #include "services/service_manager/public/cpp/service_context.h"
-#include "services/ui/ws2/gpu_support.h"
+#include "services/ui/ws2/gpu_interface_provider.h"
 #include "services/ui/ws2/window_service.h"
 #include "ui/wm/core/focus_controller.h"
 
 namespace ash {
 
 WindowServiceOwner::WindowServiceOwner(
-    std::unique_ptr<ui::ws2::GpuSupport> gpu_support)
-    : gpu_support_(std::move(gpu_support)) {}
+    std::unique_ptr<ui::ws2::GpuInterfaceProvider> gpu_interface_provider)
+    : gpu_interface_provider_(std::move(gpu_interface_provider)) {}
 
 WindowServiceOwner::~WindowServiceOwner() = default;
 
@@ -31,7 +31,7 @@ void WindowServiceOwner::BindWindowService(
   window_service_delegate_ = std::make_unique<WindowServiceDelegateImpl>();
   std::unique_ptr<ui::ws2::WindowService> window_service =
       std::make_unique<ui::ws2::WindowService>(
-          window_service_delegate_.get(), std::move(gpu_support_),
+          window_service_delegate_.get(), std::move(gpu_interface_provider_),
           Shell::Get()->focus_controller());
   window_service_ = window_service.get();
   window_service_->SetFrameDecorationValues(

ash/ws/window_service_owner.h

@@ -18,7 +18,7 @@ class ServiceContext;
 
 namespace ui {
 namespace ws2 {
-class GpuSupport;
+class GpuInterfaceProvider;
 class WindowService;
 }  // namespace ws2
 }  // namespace ui
@@ -32,7 +32,8 @@ class WindowServiceDelegateImpl;
 // BindWindowService() is called the WindowService is created.
 class ASH_EXPORT WindowServiceOwner {
  public:
-  explicit WindowServiceOwner(std::unique_ptr<ui::ws2::GpuSupport> gpu_support);
+  explicit WindowServiceOwner(
+      std::unique_ptr<ui::ws2::GpuInterfaceProvider> gpu_interface_provider);
   ~WindowServiceOwner();
 
   // Called from the ServiceManager when a request is made for the
@@ -47,7 +48,7 @@ class ASH_EXPORT WindowServiceOwner {
   friend class AshTestHelper;
 
   // Non-null until |service_context_| is created.
-  std::unique_ptr<ui::ws2::GpuSupport> gpu_support_;
+  std::unique_ptr<ui::ws2::GpuInterfaceProvider> gpu_interface_provider_;
 
   // The following state is created once BindWindowService() is called.
 

chrome/browser/ui/ash/ash_shell_init.cc

@@ -6,7 +6,7 @@
 
 #include <utility>
 
-#include "ash/content/content_gpu_support.h"
+#include "ash/content/content_gpu_interface_provider.h"
 #include "ash/display/display_prefs.h"
 #include "ash/shell.h"
 #include "ash/shell_init_params.h"
@@ -26,7 +26,8 @@ void CreateClassicShell() {
   shell_init_params.context_factory = content::GetContextFactory();
   shell_init_params.context_factory_private =
       content::GetContextFactoryPrivate();
-  shell_init_params.gpu_support = std::make_unique<ash::ContentGpuSupport>();
+  shell_init_params.gpu_interface_provider =
+      std::make_unique<ash::ContentGpuInterfaceProvider>();
   // Pass the initial display prefs to ash::Shell as a Value dictionary.
   // This is done this way to avoid complexities with registering the display
   // prefs in multiple places (i.e. in g_browser_process->local_state() and

chrome/test/base/view_event_test_platform_part_chromeos.cc

@@ -7,7 +7,7 @@
 #include <memory>
 #include <utility>
 
-#include "ash/content/content_gpu_support.h"
+#include "ash/content/content_gpu_interface_provider.h"
 #include "ash/session/test_session_controller_client.h"
 #include "ash/shell.h"
 #include "ash/shell_init_params.h"
@@ -69,7 +69,8 @@ ViewEventTestPlatformPartChromeOS::ViewEventTestPlatformPartChromeOS(
   init_params.delegate = std::make_unique<ash::TestShellDelegate>();
   init_params.context_factory = context_factory;
   init_params.context_factory_private = context_factory_private;
-  init_params.gpu_support = std::make_unique<ash::ContentGpuSupport>();
+  init_params.gpu_interface_provider =
+      std::make_unique<ash::ContentGpuInterfaceProvider>();
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kHostWindowBounds, "0+0-1280x800");
   ash::Shell::CreateInstance(std::move(init_params));

services/ui/test_ws/test_ws.cc

@@ -16,7 +16,7 @@
 #include "services/service_manager/public/cpp/service_context.h"
 #include "services/service_manager/public/cpp/service_runner.h"
 #include "services/ui/public/interfaces/window_tree_host_factory.mojom.h"
-#include "services/ui/ws2/gpu_support.h"
+#include "services/ui/ws2/gpu_interface_provider.h"
 #include "services/ui/ws2/window_service.h"
 #include "services/ui/ws2/window_service_delegate.h"
 #include "services/ui/ws2/window_tree.h"

services/ui/ws2/BUILD.gn

@@ -15,7 +15,7 @@ component("lib") {
     ":test_support",
   ]
   public = [
-    "gpu_support.h",
+    "gpu_interface_provider.h",
     "ids.h",
     "window_delegate_impl.h",
     "window_properties.h",

services/ui/ws2/gpu_interface_provider.h

+// Copyright 2018 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 SERVICES_UI_WS2_GPU_INTERFACE_PROVIDER_H_
+#define SERVICES_UI_WS2_GPU_INTERFACE_PROVIDER_H_
+
+#include "base/component_export.h"
+#include "services/service_manager/public/cpp/binder_registry.h"
+
+namespace ui {
+namespace ws2 {
+
+// GpuInterfaceProvider is responsible for providing the Gpu related interfaces.
+// The implementation of these varies depending upon where the WindowService is
+// hosted.
+class COMPONENT_EXPORT(WINDOW_SERVICE) GpuInterfaceProvider {
+ public:
+  virtual ~GpuInterfaceProvider() {}
+
+  // Registers the gpu-related interfaces, specifically
+  // discardable_memory::mojom::DiscardableSharedMemoryManagerRequest and
+  // ui::mojom::GpuRequest.
+  virtual void RegisterGpuInterfaces(
+      service_manager::BinderRegistry* registry) = 0;
+};
+
+}  // namespace ws2
+}  // namespace ui
+
+#endif  // SERVICES_UI_WS2_GPU_INTERFACE_PROVIDER_H_

services/ui/ws2/gpu_support.h

-// Copyright 2018 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 SERVICES_UI_WS2_GPU_SUPPORT_H_
-#define SERVICES_UI_WS2_GPU_SUPPORT_H_
-
-#include "base/component_export.h"
-#include "base/memory/scoped_refptr.h"
-#include "components/discardable_memory/public/interfaces/discardable_shared_memory_manager.mojom.h"
-#include "services/ui/public/interfaces/gpu.mojom.h"
-
-namespace base {
-class SingleThreadTaskRunner;
-}
-
-namespace ui {
-namespace ws2 {
-
-// GpuSupport provides the functions needed for gpu related functionality. It is
-// expected this class is bound to functions in content that do this. Once Viz
-// moves out of content, this class can be removed.
-class COMPONENT_EXPORT(WINDOW_SERVICE) GpuSupport {
- public:
-  virtual ~GpuSupport() {}
-
-  // Returns the task runner used to bind gpu related interfaces on. This is
-  // typically the io-thread.
-  virtual scoped_refptr<base::SingleThreadTaskRunner> GetGpuTaskRunner() = 0;
-
-  // The Bind functions are called when a client requests a gpu related
-  // interface.
-  virtual void BindDiscardableSharedMemoryManagerOnGpuTaskRunner(
-      discardable_memory::mojom::DiscardableSharedMemoryManagerRequest
-          request) = 0;
-  virtual void BindGpuRequestOnGpuTaskRunner(ui::mojom::GpuRequest request) = 0;
-};
-
-}  // namespace ws2
-}  // namespace ui
-
-#endif  // SERVICES_UI_WS2_GPU_SUPPORT_H_

services/ui/ws2/window_service.cc

@@ -6,7 +6,7 @@
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
-#include "services/ui/ws2/gpu_support.h"
+#include "services/ui/ws2/gpu_interface_provider.h"
 #include "services/ui/ws2/screen_provider.h"
 #include "services/ui/ws2/server_window.h"
 #include "services/ui/ws2/window_service_delegate.h"
@@ -18,11 +18,12 @@
 namespace ui {
 namespace ws2 {
 
-WindowService::WindowService(WindowServiceDelegate* delegate,
-                             std::unique_ptr<GpuSupport> gpu_support,
-                             aura::client::FocusClient* focus_client)
+WindowService::WindowService(
+    WindowServiceDelegate* delegate,
+    std::unique_ptr<GpuInterfaceProvider> gpu_interface_provider,
+    aura::client::FocusClient* focus_client)
     : delegate_(delegate),
-      gpu_support_(std::move(gpu_support)),
+      gpu_interface_provider_(std::move(gpu_interface_provider)),
       screen_provider_(std::make_unique<ScreenProvider>()),
       focus_client_(focus_client),
       ime_registrar_(&ime_driver_) {
@@ -99,18 +100,9 @@ void WindowService::OnStart() {
   registry_.AddInterface(base::BindRepeating(
       &WindowService::BindWindowTreeFactoryRequest, base::Unretained(this)));
 
-  // |gpu_support_| may be null in tests.
-  if (gpu_support_) {
-    registry_.AddInterface(
-        base::BindRepeating(
-            &GpuSupport::BindDiscardableSharedMemoryManagerOnGpuTaskRunner,
-            base::Unretained(gpu_support_.get())),
-        gpu_support_->GetGpuTaskRunner());
-    registry_.AddInterface(
-        base::BindRepeating(&GpuSupport::BindGpuRequestOnGpuTaskRunner,
-                            base::Unretained(gpu_support_.get())),
-        gpu_support_->GetGpuTaskRunner());
-  }
+  // |gpu_interface_provider_| may be null in tests.
+  if (gpu_interface_provider_)
+    gpu_interface_provider_->RegisterGpuInterfaces(&registry_);
 }
 
 void WindowService::OnBindInterface(

services/ui/ws2/window_service.h

@@ -43,7 +43,7 @@ class WindowTreeClient;
 
 namespace ws2 {
 
-class GpuSupport;
+class GpuInterfaceProvider;
 class ScreenProvider;
 class ServerWindow;
 class WindowServiceDelegate;
@@ -57,7 +57,7 @@ class COMPONENT_EXPORT(WINDOW_SERVICE) WindowService
     : public service_manager::Service {
  public:
   WindowService(WindowServiceDelegate* delegate,
-                std::unique_ptr<GpuSupport> gpu_support,
+                std::unique_ptr<GpuInterfaceProvider> gpu_support,
                 aura::client::FocusClient* focus_client);
   ~WindowService() override;
 
@@ -108,8 +108,8 @@ class COMPONENT_EXPORT(WINDOW_SERVICE) WindowService
 
   WindowServiceDelegate* delegate_;
 
-  // GpuSupport may be null in tests.
-  std::unique_ptr<GpuSupport> gpu_support_;
+  // GpuInterfaceProvider may be null in tests.
+  std::unique_ptr<GpuInterfaceProvider> gpu_interface_provider_;
 
   std::unique_ptr<ScreenProvider> screen_provider_;
 

services/ui/ws2/window_service_test_setup.cc

@@ -5,7 +5,7 @@
 #include "services/ui/ws2/window_service_test_setup.h"
 
 #include "services/ui/ws2/embedding.h"
-#include "services/ui/ws2/gpu_support.h"
+#include "services/ui/ws2/gpu_interface_provider.h"
 #include "services/ui/ws2/window_service.h"
 #include "services/ui/ws2/window_tree.h"
 #include "services/ui/ws2/window_tree_binding.h"