Migrate references to the viz::mojom::Gpu[MemoryBufferFactory] interfaces

Convert the remaining bits referencing the viz::mojom::Gpu and the
viz::mojom::GpuMemoryBufferFactory mojo interfaces using the old
APIs to the new mojo types.

TBR=kinuko@chromium.org

Bug: 955171
Change-Id: Ib210e455a9642803d6414e6daf42756eb929e0e0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1876350
Commit-Queue: Mario Sanchez Prada <mario@igalia.com>
Reviewed-by: Kenneth Russell <kbr@chromium.org>
Reviewed-by: enne <enne@chromium.org>
Reviewed-by: Oksana Zhuravlova <oksamyt@chromium.org>
Cr-Commit-Position: refs/heads/master@{#709421}

content/browser/gpu/gpu_client.cc

@@ -10,7 +10,7 @@
 namespace content {
 
 std::unique_ptr<viz::GpuClient, base::OnTaskRunnerDeleter> CreateGpuClient(
-    viz::mojom::GpuRequest request,
+    mojo::PendingReceiver<viz::mojom::Gpu> receiver,
     viz::GpuClient::ConnectionErrorHandlerClosure connection_error_handler,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   const int client_id = ChildProcessHostImpl::GenerateChildProcessUniqueId();
@@ -23,7 +23,7 @@ std::unique_ptr<viz::GpuClient, base::OnTaskRunnerDeleter> CreateGpuClient(
   gpu_client->SetConnectionErrorHandler(std::move(connection_error_handler));
   task_runner->PostTask(
       FROM_HERE, base::BindOnce(&viz::GpuClient::Add, gpu_client->GetWeakPtr(),
-                                std::move(request)));
+                                std::move(receiver)));
   return gpu_client;
 }
 

content/public/browser/gpu_client.h

@@ -9,13 +9,14 @@
 
 #include "components/viz/host/gpu_client.h"
 #include "content/common/content_export.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "services/viz/public/mojom/gpu.mojom.h"
 
 namespace content {
 
 CONTENT_EXPORT
 std::unique_ptr<viz::GpuClient, base::OnTaskRunnerDeleter> CreateGpuClient(
-    viz::mojom::GpuRequest request,
+    mojo::PendingReceiver<viz::mojom::Gpu> receiver,
     viz::GpuClient::ConnectionErrorHandlerClosure connection_error_handler,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 

services/viz/public/cpp/gpu/client_gpu_memory_buffer_manager.cc

@@ -32,7 +32,7 @@ void NotifyDestructionOnCorrectThread(
 }  // namespace
 
 ClientGpuMemoryBufferManager::ClientGpuMemoryBufferManager(
-    mojom::GpuMemoryBufferFactoryPtr gpu)
+    mojo::PendingRemote<mojom::GpuMemoryBufferFactory> gpu)
     : thread_("GpuMemoryThread"),
       gpu_memory_buffer_support_(
           std::make_unique<gpu::GpuMemoryBufferSupport>()) {
@@ -41,7 +41,7 @@ ClientGpuMemoryBufferManager::ClientGpuMemoryBufferManager(
   // the object has been destroyed. So Unretained() is safe.
   thread_.task_runner()->PostTask(
       FROM_HERE, base::BindOnce(&ClientGpuMemoryBufferManager::InitThread,
-                                base::Unretained(this), gpu.PassInterface()));
+                                base::Unretained(this), std::move(gpu)));
 }
 
 ClientGpuMemoryBufferManager::~ClientGpuMemoryBufferManager() {
@@ -52,9 +52,9 @@ ClientGpuMemoryBufferManager::~ClientGpuMemoryBufferManager() {
 }
 
 void ClientGpuMemoryBufferManager::InitThread(
-    mojom::GpuMemoryBufferFactoryPtrInfo gpu_info) {
-  gpu_.Bind(std::move(gpu_info));
-  gpu_.set_connection_error_handler(
+    mojo::PendingRemote<mojom::GpuMemoryBufferFactory> gpu_remote) {
+  gpu_.Bind(std::move(gpu_remote));
+  gpu_.set_disconnect_handler(
       base::BindOnce(&ClientGpuMemoryBufferManager::DisconnectGpuOnThread,
                      base::Unretained(this)));
   weak_ptr_ = weak_ptr_factory_.GetWeakPtr();

services/viz/public/cpp/gpu/client_gpu_memory_buffer_manager.h

@@ -14,6 +14,8 @@
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "services/viz/public/mojom/gpu.mojom.h"
 
 namespace base {
@@ -30,11 +32,13 @@ namespace viz {
 // mojom::GpuMemoryBufferFactory
 class ClientGpuMemoryBufferManager : public gpu::GpuMemoryBufferManager {
  public:
-  explicit ClientGpuMemoryBufferManager(mojom::GpuMemoryBufferFactoryPtr gpu);
+  explicit ClientGpuMemoryBufferManager(
+      mojo::PendingRemote<mojom::GpuMemoryBufferFactory> gpu);
   ~ClientGpuMemoryBufferManager() override;
 
  private:
-  void InitThread(mojom::GpuMemoryBufferFactoryPtrInfo gpu_info);
+  void InitThread(
+      mojo::PendingRemote<mojom::GpuMemoryBufferFactory> gpu_remote);
   void TearDownThread();
   void DisconnectGpuOnThread();
   void AllocateGpuMemoryBufferOnThread(const gfx::Size& size,
@@ -61,7 +65,7 @@ class ClientGpuMemoryBufferManager : public gpu::GpuMemoryBufferManager {
   int counter_ = 0;
   // TODO(sad): Explore the option of doing this from an existing thread.
   base::Thread thread_;
-  mojom::GpuMemoryBufferFactoryPtr gpu_;
+  mojo::Remote<mojom::GpuMemoryBufferFactory> gpu_;
   base::WeakPtr<ClientGpuMemoryBufferManager> weak_ptr_;
   std::set<base::WaitableEvent*> pending_allocation_waiters_;
   std::unique_ptr<gpu::GpuMemoryBufferSupport> gpu_memory_buffer_support_;

services/viz/public/cpp/gpu/gpu.cc

@@ -15,31 +15,31 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/viz/public/cpp/gpu/client_gpu_memory_buffer_manager.h"
 #include "services/viz/public/mojom/gpu.mojom.h"
 
 namespace viz {
 
-// Encapsulates a mojom::GpuPtr object that will be used on the IO thread. This
-// is required because we can't install an error handler on a
-// mojom::GpuThreadSafePtr to detect if the message pipe was closed. Only the
-// constructor can be called on the main thread.
+// Encapsulates a mojo::Remote<mojom::Gpu> object that will be used on the IO
+// thread. This is required because we can't install an error handler on a
+// mojo::SharedRemote<mojom::Gpu> to detect if the message pipe was closed. Only
+// the constructor can be called on the main thread.
 class Gpu::GpuPtrIO {
  public:
   GpuPtrIO() { DETACH_FROM_THREAD(thread_checker_); }
   ~GpuPtrIO() { DCHECK_CALLED_ON_VALID_THREAD(thread_checker_); }
 
-  void Initialize(mojom::GpuPtrInfo ptr_info,
+  void Initialize(mojo::PendingRemote<mojom::Gpu> gpu_remote,
                   mojo::PendingReceiver<mojom::GpuMemoryBufferFactory>
                       memory_buffer_factory_receiver) {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
-    gpu_ptr_.Bind(std::move(ptr_info));
-    gpu_ptr_.set_connection_error_handler(
+    gpu_remote_.Bind(std::move(gpu_remote));
+    gpu_remote_.set_disconnect_handler(
         base::BindOnce(&GpuPtrIO::ConnectionError, base::Unretained(this)));
-    gpu_ptr_->CreateGpuMemoryBufferFactory(
+    gpu_remote_->CreateGpuMemoryBufferFactory(
         std::move(memory_buffer_factory_receiver));
   }
 
@@ -48,11 +48,11 @@ class Gpu::GpuPtrIO {
     DCHECK(!establish_request_);
     establish_request_ = std::move(establish_request);
 
-    if (gpu_ptr_.encountered_error()) {
-      ConnectionError();
-    } else {
-      gpu_ptr_->EstablishGpuChannel(base::BindOnce(
+    if (gpu_remote_.is_connected()) {
+      gpu_remote_->EstablishGpuChannel(base::BindOnce(
           &GpuPtrIO::OnEstablishedGpuChannel, base::Unretained(this)));
+    } else {
+      ConnectionError();
     }
   }
 
@@ -61,7 +61,7 @@ class Gpu::GpuPtrIO {
       mojo::PendingReceiver<chromeos_camera::mojom::MjpegDecodeAccelerator>
           receiver) {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-    gpu_ptr_->CreateJpegDecodeAccelerator(std::move(receiver));
+    gpu_remote_->CreateJpegDecodeAccelerator(std::move(receiver));
   }
 #endif  // defined(OS_CHROMEOS)
 
@@ -69,7 +69,7 @@ class Gpu::GpuPtrIO {
       mojo::PendingReceiver<media::mojom::VideoEncodeAcceleratorProvider>
           receiver) {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-    gpu_ptr_->CreateVideoEncodeAcceleratorProvider(std::move(receiver));
+    gpu_remote_->CreateVideoEncodeAcceleratorProvider(std::move(receiver));
   }
 
  private:
@@ -79,7 +79,7 @@ class Gpu::GpuPtrIO {
                                const gpu::GPUInfo& gpu_info,
                                const gpu::GpuFeatureInfo& gpu_feature_info);
 
-  mojom::GpuPtr gpu_ptr_;
+  mojo::Remote<mojom::Gpu> gpu_remote_;
 
   // This will point to a request that is waiting for the result of
   // EstablishGpuChannel(). |establish_request_| will be notified when the IPC
@@ -233,7 +233,7 @@ void Gpu::GpuPtrIO::OnEstablishedGpuChannel(
   establish_request_.reset();
 }
 
-Gpu::Gpu(mojom::GpuPtr gpu_ptr,
+Gpu::Gpu(mojo::PendingRemote<mojom::Gpu> gpu_remote,
          scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       io_task_runner_(std::move(task_runner)),
@@ -241,20 +241,20 @@ Gpu::Gpu(mojom::GpuPtr gpu_ptr,
   DCHECK(main_task_runner_);
   DCHECK(io_task_runner_);
 
-  mojom::GpuMemoryBufferFactoryPtr gpu_memory_buffer_factory;
-  auto gpu_memory_buffer_factory_request =
-      mojo::MakeRequest(&gpu_memory_buffer_factory);
+  mojo::PendingRemote<mojom::GpuMemoryBufferFactory> gpu_memory_buffer_factory;
+  auto gpu_memory_buffer_factory_receiver =
+      gpu_memory_buffer_factory.InitWithNewPipeAndPassReceiver();
   gpu_memory_buffer_manager_ = std::make_unique<ClientGpuMemoryBufferManager>(
       std::move(gpu_memory_buffer_factory));
-  // Initialize mojom::GpuPtr on the IO thread. |gpu_| can only be used on
-  // the IO thread after this point. It is safe to use base::Unretained with
-  // |gpu_| for IO thread tasks as |gpu_| is destroyed by an IO thread task
+  // Initialize mojo::Remote<mojom::Gpu> on the IO thread. |gpu_| can only be
+  // used on the IO thread after this point. It is safe to use base::Unretained
+  // with |gpu_| for IO thread tasks as |gpu_| is destroyed by an IO thread task
   // posted from the destructor.
   io_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&GpuPtrIO::Initialize, base::Unretained(gpu_.get()),
-                     base::Passed(gpu_ptr.PassInterface()),
-                     std::move(gpu_memory_buffer_factory_request)));
+                     base::Passed(std::move(gpu_remote)),
+                     std::move(gpu_memory_buffer_factory_receiver)));
 }
 
 Gpu::~Gpu() {
@@ -282,9 +282,8 @@ std::unique_ptr<Gpu> Gpu::Create(
 std::unique_ptr<Gpu> Gpu::Create(
     mojo::PendingRemote<mojom::Gpu> remote,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) {
-  mojom::GpuPtr gpu_ptr(std::move(remote));
   return base::WrapUnique(
-      new Gpu(std::move(gpu_ptr), std::move(io_task_runner)));
+      new Gpu(std::move(remote), std::move(io_task_runner)));
 }
 
 #if defined(OS_CHROMEOS)

services/viz/public/cpp/gpu/gpu.h

@@ -66,7 +66,7 @@ class Gpu : public gpu::GpuChannelEstablishFactory {
   class GpuPtrIO;
   class EstablishRequest;
 
-  Gpu(mojom::GpuPtr gpu_ptr,
+  Gpu(mojo::PendingRemote<mojom::Gpu> gpu_remote,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
   // Sends a request to establish a gpu channel. If a request is currently

services/viz/public/cpp/gpu/gpu_unittest.cc

@@ -13,7 +13,9 @@
 #include "build/build_config.h"
 #include "gpu/config/gpu_feature_info.h"
 #include "gpu/config/gpu_info.h"
-#include "mojo/public/cpp/bindings/binding_set.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace viz {
@@ -31,8 +33,8 @@ class TestGpuImpl : public mojom::Gpu {
 
   void CloseBindingOnRequest() { close_binding_on_request_ = true; }
 
-  void BindRequest(mojom::GpuRequest request) {
-    bindings_.AddBinding(this, std::move(request));
+  void BindReceiver(mojo::PendingReceiver<mojom::Gpu> receiver) {
+    receivers_.Add(this, std::move(receiver));
   }
 
   // mojom::Gpu overrides:
@@ -42,7 +44,7 @@ class TestGpuImpl : public mojom::Gpu {
   void EstablishGpuChannel(EstablishGpuChannelCallback callback) override {
     if (close_binding_on_request_) {
       // Don't run |callback| and trigger a connection error on the other end.
-      bindings_.CloseAllBindings();
+      receivers_.Clear();
       return;
     }
 
@@ -71,7 +73,7 @@ class TestGpuImpl : public mojom::Gpu {
  private:
   bool request_will_succeed_ = true;
   bool close_binding_on_request_ = false;
-  mojo::BindingSet<mojom::Gpu> bindings_;
+  mojo::ReceiverSet<mojom::Gpu> receivers_;
 
   // Closing this handle will result in GpuChannelHost being lost.
   mojo::ScopedMessagePipeHandle gpu_channel_handle_;
@@ -127,7 +129,7 @@ class GpuTest : public testing::Test {
   // testing::Test:
   void SetUp() override {
     gpu_impl_ = std::make_unique<TestGpuImpl>();
-    gpu_ = base::WrapUnique(new Gpu(GetPtr(), io_thread_.task_runner()));
+    gpu_ = base::WrapUnique(new Gpu(GetRemote(), io_thread_.task_runner()));
   }
 
   void TearDown() override {
@@ -136,13 +138,14 @@ class GpuTest : public testing::Test {
   }
 
  private:
-  mojom::GpuPtr GetPtr() {
-    mojom::GpuPtr ptr;
+  mojo::PendingRemote<mojom::Gpu> GetRemote() {
+    mojo::PendingRemote<mojom::Gpu> remote;
     io_thread_.task_runner()->PostTask(
-        FROM_HERE, base::BindOnce(&TestGpuImpl::BindRequest,
-                                  base::Unretained(gpu_impl_.get()),
-                                  base::Passed(MakeRequest(&ptr))));
-    return ptr;
+        FROM_HERE,
+        base::BindOnce(&TestGpuImpl::BindReceiver,
+                       base::Unretained(gpu_impl_.get()),
+                       base::Passed(remote.InitWithNewPipeAndPassReceiver())));
+    return remote;
   }
 
   void DestroyGpuImplOnIO() {