Remove GpuChannelHostFactory

At this point it's only used to get to the IO thread, pass that
explicitly instead.

Bug: 566273
Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: I374215f47024361af958ca0c94250949920f1bd0
Reviewed-on: https://chromium-review.googlesource.com/797917Reviewed-by: Sadrul Chowdhury <sadrul@chromium.org>
Commit-Queue: Antoine Labour <piman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#520619}

content/browser/gpu/browser_gpu_channel_host_factory.cc

@@ -232,8 +232,8 @@ BrowserGpuChannelHostFactory::BrowserGpuChannelHostFactory()
     base::FilePath cache_dir =
         GetContentClient()->browser()->GetShaderDiskCacheDirectory();
     if (!cache_dir.empty()) {
-      GetIOThreadTaskRunner()->PostTask(
-          FROM_HERE,
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
           base::BindOnce(
               &BrowserGpuChannelHostFactory::InitializeShaderDiskCacheOnIO,
               gpu_client_id_, cache_dir));
@@ -251,11 +251,6 @@ BrowserGpuChannelHostFactory::~BrowserGpuChannelHostFactory() {
   }
 }
 
-scoped_refptr<base::SingleThreadTaskRunner>
-BrowserGpuChannelHostFactory::GetIOThreadTaskRunner() {
-  return BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
-}
-
 void BrowserGpuChannelHostFactory::EstablishGpuChannel(
     const gpu::GpuChannelEstablishedCallback& callback) {
 #if defined(USE_AURA)
@@ -324,7 +319,8 @@ void BrowserGpuChannelHostFactory::GpuChannelEstablished() {
   } else {
     GetContentClient()->SetGpuInfo(pending_request_->gpu_info());
     gpu_channel_ = base::MakeRefCounted<gpu::GpuChannelHost>(
-        this, gpu_client_id_, pending_request_->gpu_info(),
+        BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
+        gpu_client_id_, pending_request_->gpu_info(),
         pending_request_->gpu_feature_info(), std::move(handle),
         gpu_memory_buffer_manager_.get());
   }

content/browser/gpu/browser_gpu_channel_host_factory.h

@@ -24,16 +24,12 @@ namespace content {
 class BrowserGpuMemoryBufferManager;
 
 class CONTENT_EXPORT BrowserGpuChannelHostFactory
-    : public gpu::GpuChannelHostFactory,
-      public gpu::GpuChannelEstablishFactory {
+    : public gpu::GpuChannelEstablishFactory {
  public:
   static void Initialize(bool establish_gpu_channel);
   static void Terminate();
   static BrowserGpuChannelHostFactory* instance() { return instance_; }
 
-  // Overridden from gpu::GpuChannelHostFactory:
-  scoped_refptr<base::SingleThreadTaskRunner> GetIOThreadTaskRunner() override;
-
   gpu::GpuChannelHost* GetGpuChannel();
   int GetGpuChannelId() { return gpu_client_id_; }
 

gpu/ipc/client/gpu_channel_host.cc

@@ -31,19 +31,18 @@ base::AtomicSequenceNumber g_next_transfer_buffer_id;
 }  // namespace
 
 GpuChannelHost::GpuChannelHost(
-    GpuChannelHostFactory* factory,
+    scoped_refptr<base::SingleThreadTaskRunner> io_thread,
     int channel_id,
     const gpu::GPUInfo& gpu_info,
     const gpu::GpuFeatureInfo& gpu_feature_info,
     mojo::ScopedMessagePipeHandle handle,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager)
-    : factory_(factory),
+    : io_thread_(std::move(io_thread)),
       channel_id_(channel_id),
       gpu_info_(gpu_info),
       gpu_feature_info_(gpu_feature_info),
-      listener_(
-          new Listener(std::move(handle), factory_->GetIOThreadTaskRunner()),
-          base::OnTaskRunnerDeleter(factory_->GetIOThreadTaskRunner())),
+      listener_(new Listener(std::move(handle), io_thread_),
+                base::OnTaskRunnerDeleter(io_thread_)),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager) {
   next_image_id_.GetNext();
   next_route_id_.GetNext();
@@ -56,19 +55,17 @@ bool GpuChannelHost::Send(IPC::Message* msg) {
 
   auto message = base::WrapUnique(msg);
 
-  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner =
-      factory_->GetIOThreadTaskRunner();
-  DCHECK(!io_task_runner->BelongsToCurrentThread());
+  DCHECK(!io_thread_->BelongsToCurrentThread());
 
   // The GPU process never sends synchronous IPCs so clear the unblock flag to
   // preserve order.
   message->set_unblock(false);
 
   if (!message->is_sync()) {
-    io_task_runner->PostTask(FROM_HERE,
-                             base::BindOnce(&Listener::SendMessage,
-                                            base::Unretained(listener_.get()),
-                                            std::move(message), nullptr));
+    io_thread_->PostTask(FROM_HERE,
+                         base::BindOnce(&Listener::SendMessage,
+                                        base::Unretained(listener_.get()),
+                                        std::move(message), nullptr));
     return true;
   }
 
@@ -80,7 +77,7 @@ bool GpuChannelHost::Send(IPC::Message* msg) {
 
   IPC::PendingSyncMsg pending_sync(IPC::SyncMessage::GetMessageId(*message),
                                    deserializer.get(), &done_event);
-  io_task_runner->PostTask(
+  io_thread_->PostTask(
       FROM_HERE,
       base::BindOnce(&Listener::SendMessage, base::Unretained(listener_.get()),
                      std::move(message), &pending_sync));
@@ -144,7 +141,7 @@ void GpuChannelHost::InternalFlush(uint32_t flush_id) {
 }
 
 void GpuChannelHost::DestroyChannel() {
-  factory_->GetIOThreadTaskRunner()->PostTask(
+  io_thread_->PostTask(
       FROM_HERE,
       base::BindOnce(&Listener::Close, base::Unretained(listener_.get())));
 }
@@ -159,20 +156,16 @@ void GpuChannelHost::AddRouteWithTaskRunner(
     int route_id,
     base::WeakPtr<IPC::Listener> listener,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner =
-      factory_->GetIOThreadTaskRunner();
-  io_task_runner->PostTask(
-      FROM_HERE, base::Bind(&GpuChannelHost::Listener::AddRoute,
-                            base::Unretained(listener_.get()), route_id,
-                            listener, task_runner));
+  io_thread_->PostTask(FROM_HERE,
+                       base::Bind(&GpuChannelHost::Listener::AddRoute,
+                                  base::Unretained(listener_.get()), route_id,
+                                  listener, task_runner));
 }
 
 void GpuChannelHost::RemoveRoute(int route_id) {
-  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner =
-      factory_->GetIOThreadTaskRunner();
-  io_task_runner->PostTask(
-      FROM_HERE, base::Bind(&GpuChannelHost::Listener::RemoveRoute,
-                            base::Unretained(listener_.get()), route_id));
+  io_thread_->PostTask(FROM_HERE,
+                       base::Bind(&GpuChannelHost::Listener::RemoveRoute,
+                                  base::Unretained(listener_.get()), route_id));
 }
 
 base::SharedMemoryHandle GpuChannelHost::ShareToGpuProcess(

gpu/ipc/client/gpu_channel_host.h

@@ -57,14 +57,6 @@ class GPU_EXPORT GpuChannelEstablishFactory {
   virtual GpuMemoryBufferManager* GetGpuMemoryBufferManager() = 0;
 };
 
-class GPU_EXPORT GpuChannelHostFactory {
- public:
-  virtual ~GpuChannelHostFactory() {}
-
-  virtual scoped_refptr<base::SingleThreadTaskRunner>
-  GetIOThreadTaskRunner() = 0;
-};
-
 // Encapsulates an IPC channel between the client and one GPU process.
 // On the GPU process side there's a corresponding GpuChannel.
 // Every method can be called on any thread with a message loop, except for the
@@ -73,7 +65,7 @@ class GPU_EXPORT GpuChannelHost
     : public IPC::Sender,
       public base::RefCountedThreadSafe<GpuChannelHost> {
  public:
-  GpuChannelHost(GpuChannelHostFactory* factory,
+  GpuChannelHost(scoped_refptr<base::SingleThreadTaskRunner> io_thread,
                  int channel_id,
                  const gpu::GPUInfo& gpu_info,
                  const gpu::GpuFeatureInfo& gpu_feature_info,
@@ -129,8 +121,6 @@ class GPU_EXPORT GpuChannelHost
   // Remove the message route associated with |route_id|.
   void RemoveRoute(int route_id);
 
-  GpuChannelHostFactory* factory() const { return factory_; }
-
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager() const {
     return gpu_memory_buffer_manager_;
   }
@@ -223,7 +213,7 @@ class GPU_EXPORT GpuChannelHost
   // - |next_image_id_|, atomic type
   // - |next_route_id_|, atomic type
   // - |flush_list_| and |*_flush_id_| protected by |context_lock_|
-  GpuChannelHostFactory* const factory_;
+  const scoped_refptr<base::SingleThreadTaskRunner> io_thread_;
 
   const int channel_id_;
   const gpu::GPUInfo gpu_info_;

services/ui/public/cpp/gpu/gpu.cc

@@ -295,8 +295,8 @@ void Gpu::OnEstablishedGpuChannel() {
   if (pending_request_->client_id() &&
       pending_request_->channel_handle().is_valid()) {
     gpu_channel_ = base::MakeRefCounted<gpu::GpuChannelHost>(
-        this, pending_request_->client_id(), pending_request_->gpu_info(),
-        pending_request_->gpu_feature_info(),
+        io_task_runner_, pending_request_->client_id(),
+        pending_request_->gpu_info(), pending_request_->gpu_feature_info(),
         std::move(pending_request_->channel_handle()),
         gpu_memory_buffer_manager_.get());
   }
@@ -308,8 +308,4 @@ void Gpu::OnEstablishedGpuChannel() {
     callback.Run(gpu_channel_);
 }
 
-scoped_refptr<base::SingleThreadTaskRunner> Gpu::GetIOThreadTaskRunner() {
-  return io_task_runner_;
-}
-
 }  // namespace ui

services/ui/public/cpp/gpu/gpu.h

@@ -22,8 +22,7 @@ class Connector;
 
 namespace ui {
 
-class Gpu : public gpu::GpuChannelHostFactory,
-            public gpu::GpuChannelEstablishFactory {
+class Gpu : public gpu::GpuChannelEstablishFactory {
  public:
   // The Gpu has to be initialized in the main thread before establishing
   // the gpu channel.
@@ -73,9 +72,6 @@ class Gpu : public gpu::GpuChannelHostFactory,
   // |pending_request_|.
   void OnEstablishedGpuChannel();
 
-  // gpu::GpuChannelHostFactory overrides:
-  scoped_refptr<base::SingleThreadTaskRunner> GetIOThreadTaskRunner() override;
-
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   std::unique_ptr<ClientGpuMemoryBufferManager> gpu_memory_buffer_manager_;