Migrate references of viz::mojom::FrameSinkManager to new Mojo types

Convert the remaining bits in both the implementation and clients from
the browser and renderer processes for the viz::mojom::FrameSinkManager
interface, and adapt unit tests.

Bug: 955171, 978694
Change-Id: I8a7ea0d64ec447de26e52a2b65f7620009be44ac
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1860028Reviewed-by: danakj <danakj@chromium.org>
Reviewed-by: Ken Buchanan <kenrb@chromium.org>
Reviewed-by: enne <enne@chromium.org>
Reviewed-by: Oksana Zhuravlova <oksamyt@chromium.org>
Reviewed-by: Dominick Ng <dominickn@chromium.org>
Commit-Queue: Mario Sanchez Prada <mario@igalia.com>
Cr-Commit-Position: refs/heads/master@{#706439}

components/viz/demo/demo_main.cc

@@ -16,6 +16,8 @@
 #include "components/viz/demo/service/demo_service.h"
 #include "mojo/core/embedder/embedder.h"
 #include "mojo/core/embedder/scoped_ipc_support.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/platform_window/platform_window_base.h"
 #include "ui/platform_window/platform_window_delegate.h"
@@ -134,9 +136,10 @@ class DemoWindow : public ui::PlatformWindowDelegate {
     // actual process of setting up the viz host and the service.
     // First, set up the mojo message-pipes that the host and the service will
     // use to communicate with each other.
-    viz::mojom::FrameSinkManagerPtr frame_sink_manager;
-    viz::mojom::FrameSinkManagerRequest frame_sink_manager_request =
-        mojo::MakeRequest(&frame_sink_manager);
+    mojo::PendingRemote<viz::mojom::FrameSinkManager> frame_sink_manager;
+    mojo::PendingReceiver<viz::mojom::FrameSinkManager>
+        frame_sink_manager_receiver =
+            frame_sink_manager.InitWithNewPipeAndPassReceiver();
     viz::mojom::FrameSinkManagerClientPtr frame_sink_manager_client;
     viz::mojom::FrameSinkManagerClientRequest
         frame_sink_manager_client_request =
@@ -150,7 +153,7 @@ class DemoWindow : public ui::PlatformWindowDelegate {
         std::move(frame_sink_manager));
 
     service_ = std::make_unique<demo::DemoService>(
-        std::move(frame_sink_manager_request),
+        std::move(frame_sink_manager_receiver),
         std::move(frame_sink_manager_client));
   }
 

components/viz/demo/host/demo_host.cc

@@ -10,20 +10,20 @@
 #include "components/viz/demo/client/demo_client.h"
 #include "components/viz/host/renderer_settings_creation.h"
 #include "mojo/public/cpp/bindings/pending_associated_remote.h"
-#include "mojo/public/cpp/bindings/pending_remote.h"
 
 namespace demo {
 
-DemoHost::DemoHost(gfx::AcceleratedWidget widget,
-                   const gfx::Size& size,
-                   viz::mojom::FrameSinkManagerClientRequest client_request,
-                   viz::mojom::FrameSinkManagerPtr frame_sink_manager_ptr)
+DemoHost::DemoHost(
+    gfx::AcceleratedWidget widget,
+    const gfx::Size& size,
+    viz::mojom::FrameSinkManagerClientRequest client_request,
+    mojo::PendingRemote<viz::mojom::FrameSinkManager> frame_sink_manager_remote)
     : widget_(widget), size_(size), thread_("DemoHost") {
   CHECK(thread_.Start());
   thread_.task_runner()->PostTask(
       FROM_HERE, base::BindOnce(&DemoHost::Initialize, base::Unretained(this),
                                 std::move(client_request),
-                                frame_sink_manager_ptr.PassInterface()));
+                                std::move(frame_sink_manager_remote)));
 }
 
 DemoHost::~DemoHost() = default;
@@ -112,11 +112,11 @@ void DemoHost::EmbedClients(DemoClient* embedder_client,
   embedded_clients_.push_back(std::move(embedded_client));
 }
 
-void DemoHost::Initialize(viz::mojom::FrameSinkManagerClientRequest request,
-                          viz::mojom::FrameSinkManagerPtrInfo ptr_info) {
-  host_frame_sink_manager_.BindAndSetManager(
-      std::move(request), nullptr,
-      viz::mojom::FrameSinkManagerPtr(std::move(ptr_info)));
+void DemoHost::Initialize(
+    viz::mojom::FrameSinkManagerClientRequest request,
+    mojo::PendingRemote<viz::mojom::FrameSinkManager> remote) {
+  host_frame_sink_manager_.BindAndSetManager(std::move(request), nullptr,
+                                             std::move(remote));
 
   display_client_ = std::make_unique<viz::HostDisplayClient>(widget_);
 

components/viz/demo/host/demo_host.h

@@ -13,6 +13,7 @@
 #include "components/viz/host/host_display_client.h"
 #include "components/viz/host/host_frame_sink_client.h"
 #include "components/viz/host/host_frame_sink_manager.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/viz/privileged/mojom/compositing/display_private.mojom.h"
 #include "services/viz/privileged/mojom/compositing/frame_sink_manager.mojom.h"
 #include "ui/gfx/native_widget_types.h"
@@ -29,7 +30,8 @@ class DemoHost : public viz::HostFrameSinkClient {
   DemoHost(gfx::AcceleratedWidget widget,
            const gfx::Size& size,
            viz::mojom::FrameSinkManagerClientRequest client_request,
-           viz::mojom::FrameSinkManagerPtr frame_sink_manager_ptr);
+           mojo::PendingRemote<viz::mojom::FrameSinkManager>
+               frame_sink_manager_remote);
   ~DemoHost() override;
 
   void Resize(const gfx::Size& size);
@@ -40,7 +42,7 @@ class DemoHost : public viz::HostFrameSinkClient {
   void EmbedClients(DemoClient* embedder_client, const gfx::Rect& child_bounds);
 
   void Initialize(viz::mojom::FrameSinkManagerClientRequest request,
-                  viz::mojom::FrameSinkManagerPtrInfo ptr_info);
+                  mojo::PendingRemote<viz::mojom::FrameSinkManager> remote);
 
   // viz::HostFrameSinkClient:
   void OnFirstSurfaceActivation(const viz::SurfaceInfo& surface_info) override;

components/viz/demo/service/demo_service.cc

@@ -12,13 +12,14 @@
 
 namespace demo {
 
-DemoService::DemoService(viz::mojom::FrameSinkManagerRequest request,
-                         viz::mojom::FrameSinkManagerClientPtr client) {
+DemoService::DemoService(
+    mojo::PendingReceiver<viz::mojom::FrameSinkManager> receiver,
+    viz::mojom::FrameSinkManagerClientPtr client) {
   auto params = viz::mojom::FrameSinkManagerParams::New();
   params->restart_id = viz::BeginFrameSource::kNotRestartableId;
   params->use_activation_deadline = false;
   params->activation_deadline_in_frames = 0u;
-  params->frame_sink_manager = std::move(request);
+  params->frame_sink_manager = std::move(receiver);
   params->frame_sink_manager_client = client.PassInterface();
   runner_ = std::make_unique<viz::VizCompositorThreadRunnerImpl>();
   runner_->CreateFrameSinkManager(std::move(params));

components/viz/demo/service/demo_service.h

@@ -8,6 +8,7 @@
 #include <memory>
 
 #include "base/threading/thread.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "services/viz/privileged/mojom/compositing/frame_sink_manager.mojom.h"
 
 namespace viz {
@@ -22,7 +23,7 @@ namespace demo {
 // the host over the mojom.FrameSinkManagerClient API.
 class DemoService {
  public:
-  DemoService(viz::mojom::FrameSinkManagerRequest request,
+  DemoService(mojo::PendingReceiver<viz::mojom::FrameSinkManager> receiver,
               viz::mojom::FrameSinkManagerClientPtr client);
   ~DemoService();
 

components/viz/host/gpu_host_impl.cc

@@ -176,7 +176,7 @@ void GpuHostImpl::BlockLiveOffscreenContexts() {
 }
 
 void GpuHostImpl::ConnectFrameSinkManager(
-    mojom::FrameSinkManagerRequest request,
+    mojo::PendingReceiver<mojom::FrameSinkManager> receiver,
     mojom::FrameSinkManagerClientPtrInfo client) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   TRACE_EVENT0("gpu", "GpuHostImpl::ConnectFrameSinkManager");
@@ -188,7 +188,7 @@ void GpuHostImpl::ConnectFrameSinkManager(
       params_.deadline_to_synchronize_surfaces.has_value();
   params->activation_deadline_in_frames =
       params_.deadline_to_synchronize_surfaces.value_or(0u);
-  params->frame_sink_manager = std::move(request);
+  params->frame_sink_manager = std::move(receiver);
   params->frame_sink_manager_client = std::move(client);
   viz_main_->CreateFrameSinkManager(std::move(params));
 }

components/viz/host/gpu_host_impl.h

@@ -148,8 +148,9 @@ class VIZ_HOST_EXPORT GpuHostImpl : public mojom::GpuHost {
   void BlockLiveOffscreenContexts();
 
   // Connects to FrameSinkManager running in the Viz service.
-  void ConnectFrameSinkManager(mojom::FrameSinkManagerRequest request,
-                               mojom::FrameSinkManagerClientPtrInfo client);
+  void ConnectFrameSinkManager(
+      mojo::PendingReceiver<mojom::FrameSinkManager> receiver,
+      mojom::FrameSinkManagerClientPtrInfo client);
 
 #if BUILDFLAG(USE_VIZ_DEVTOOLS)
   // Connects to Viz DevTools running in the Viz service.

components/viz/host/host_frame_sink_manager.cc

@@ -27,7 +27,7 @@ HostFrameSinkManager::~HostFrameSinkManager() = default;
 
 void HostFrameSinkManager::SetLocalManager(
     FrameSinkManagerImpl* frame_sink_manager_impl) {
-  DCHECK(!frame_sink_manager_ptr_);
+  DCHECK(!frame_sink_manager_remote_);
   frame_sink_manager_impl_ = frame_sink_manager_impl;
 
   frame_sink_manager_ = frame_sink_manager_impl;
@@ -36,15 +36,15 @@ void HostFrameSinkManager::SetLocalManager(
 void HostFrameSinkManager::BindAndSetManager(
     mojom::FrameSinkManagerClientRequest request,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-    mojom::FrameSinkManagerPtr ptr) {
+    mojo::PendingRemote<mojom::FrameSinkManager> remote) {
   DCHECK(!frame_sink_manager_impl_);
   DCHECK(!binding_.is_bound());
 
   binding_.Bind(std::move(request), std::move(task_runner));
-  frame_sink_manager_ptr_ = std::move(ptr);
-  frame_sink_manager_ = frame_sink_manager_ptr_.get();
+  frame_sink_manager_remote_.Bind(std::move(remote));
+  frame_sink_manager_ = frame_sink_manager_remote_.get();
 
-  frame_sink_manager_ptr_.set_connection_error_handler(base::BindOnce(
+  frame_sink_manager_remote_.set_disconnect_handler(base::BindOnce(
       &HostFrameSinkManager::OnConnectionLost, base::Unretained(this)));
 
   if (connection_was_lost_) {
@@ -143,7 +143,7 @@ void HostFrameSinkManager::SetFrameSinkDebugLabel(
 void HostFrameSinkManager::CreateRootCompositorFrameSink(
     mojom::RootCompositorFrameSinkParamsPtr params) {
   // Should only be used with an out-of-process display compositor.
-  DCHECK(frame_sink_manager_ptr_);
+  DCHECK(frame_sink_manager_remote_);
 
   FrameSinkId frame_sink_id = params->frame_sink_id;
   FrameSinkData& data = frame_sink_data_map_[frame_sink_id];
@@ -347,7 +347,7 @@ void HostFrameSinkManager::OnConnectionLost() {
   connection_was_lost_ = true;
 
   binding_.Close();
-  frame_sink_manager_ptr_.reset();
+  frame_sink_manager_remote_.reset();
   frame_sink_manager_ = nullptr;
 
   // Any cached back buffers are invalid once the connection to the
@@ -431,15 +431,15 @@ uint32_t HostFrameSinkManager::CacheBackBufferForRootSink(
   DCHECK(it != frame_sink_data_map_.end());
   DCHECK(it->second.is_root);
   DCHECK(it->second.IsFrameSinkRegistered());
-  DCHECK(frame_sink_manager_ptr_);
+  DCHECK(frame_sink_manager_remote_);
 
   uint32_t cache_id = next_cache_back_buffer_id_++;
-  frame_sink_manager_ptr_->CacheBackBuffer(cache_id, root_sink_id);
+  frame_sink_manager_remote_->CacheBackBuffer(cache_id, root_sink_id);
   return cache_id;
 }
 
 void HostFrameSinkManager::EvictCachedBackBuffer(uint32_t cache_id) {
-  DCHECK(frame_sink_manager_ptr_);
+  DCHECK(frame_sink_manager_remote_);
 
   if (cache_id < min_valid_cache_back_buffer_id_)
     return;
@@ -448,7 +448,7 @@ void HostFrameSinkManager::EvictCachedBackBuffer(uint32_t cache_id) {
   // the platform window (eg. XWindow or HWND) get destroyed before the
   // platform window is destroyed.
   mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
-  frame_sink_manager_ptr_->EvictBackBuffer(cache_id);
+  frame_sink_manager_remote_->EvictBackBuffer(cache_id);
 }
 
 HostFrameSinkManager::FrameSinkData::FrameSinkData() = default;

components/viz/host/host_frame_sink_manager.h

@@ -27,6 +27,7 @@
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "services/viz/privileged/mojom/compositing/frame_sink_manager.mojom.h"
 
 namespace base {
@@ -68,10 +69,10 @@ class VIZ_HOST_EXPORT HostFrameSinkManager
   void BindAndSetManager(
       mojom::FrameSinkManagerClientRequest request,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-      mojom::FrameSinkManagerPtr ptr);
+      mojo::PendingRemote<mojom::FrameSinkManager> remote);
 
   // Sets a callback to be notified when the connection to the FrameSinkManager
-  // on |frame_sink_manager_ptr_| is lost.
+  // on |frame_sink_manager_remote_| is lost.
   void SetConnectionLostCallback(base::RepeatingClosure callback);
 
   // Sets a callback to be notified after Viz sent bad message to Viz host.
@@ -256,7 +257,7 @@ class VIZ_HOST_EXPORT HostFrameSinkManager
     DISALLOW_COPY_AND_ASSIGN(FrameSinkData);
   };
 
-  // Handles connection loss to |frame_sink_manager_ptr_|. This should only
+  // Handles connection loss to |frame_sink_manager_remote_|. This should only
   // happen when the GPU process crashes.
   void OnConnectionLost();
 
@@ -269,28 +270,28 @@ class VIZ_HOST_EXPORT HostFrameSinkManager
       const FrameSinkId& frame_sink_id,
       const std::vector<AggregatedHitTestRegion>& hit_test_data) override;
 
-  // This will point to |frame_sink_manager_ptr_| if using Mojo or
+  // This will point to |frame_sink_manager_remote_| if using Mojo or
   // |frame_sink_manager_impl_| if directly connected. Use this to make function
   // calls.
   mojom::FrameSinkManager* frame_sink_manager_ = nullptr;
 
   // Mojo connection to the FrameSinkManager. If this is bound then
   // |frame_sink_manager_impl_| must be null.
-  mojom::FrameSinkManagerPtr frame_sink_manager_ptr_;
+  mojo::Remote<mojom::FrameSinkManager> frame_sink_manager_remote_;
 
   // Mojo connection back from the FrameSinkManager.
   mojo::Binding<mojom::FrameSinkManagerClient> binding_;
 
   // A direct connection to FrameSinkManagerImpl. If this is set then
-  // |frame_sink_manager_ptr_| must be unbound. For use in browser process only,
-  // viz process should not set this.
+  // |frame_sink_manager_remote_| must be unbound. For use in browser process
+  // only, viz process should not set this.
   FrameSinkManagerImpl* frame_sink_manager_impl_ = nullptr;
 
   // Per CompositorFrameSink data.
   std::unordered_map<FrameSinkId, FrameSinkData, FrameSinkIdHash>
       frame_sink_data_map_;
 
-  // If |frame_sink_manager_ptr_| connection was lost.
+  // If |frame_sink_manager_remote_| connection was lost.
   bool connection_was_lost_ = false;
 
   base::RepeatingClosure connection_lost_callback_;

components/viz/host/host_frame_sink_manager_unittest.cc

@@ -134,7 +134,7 @@ class HostFrameSinkManagerTestBase : public testing::Test {
   }
 
   bool IsBoundToFrameSinkManager() {
-    return host_manager_->frame_sink_manager_ptr_.is_bound() ||
+    return host_manager_->frame_sink_manager_remote_.is_bound() ||
            host_manager_->binding_.is_bound();
   }
 
@@ -206,9 +206,9 @@ class HostFrameSinkManagerRemoteTest : public HostFrameSinkManagerTestBase {
         std::make_unique<testing::NiceMock<MockFrameSinkManagerImpl>>(
             &shared_bitmap_manager_);
 
-    mojom::FrameSinkManagerPtr frame_sink_manager;
-    mojom::FrameSinkManagerRequest frame_sink_manager_request =
-        mojo::MakeRequest(&frame_sink_manager);
+    mojo::PendingRemote<mojom::FrameSinkManager> frame_sink_manager;
+    mojo::PendingReceiver<mojom::FrameSinkManager> frame_sink_manager_receiver =
+        frame_sink_manager.InitWithNewPipeAndPassReceiver();
     mojom::FrameSinkManagerClientPtr frame_sink_manager_client;
     mojom::FrameSinkManagerClientRequest frame_sink_manager_client_request =
         mojo::MakeRequest(&frame_sink_manager_client);
@@ -216,7 +216,7 @@ class HostFrameSinkManagerRemoteTest : public HostFrameSinkManagerTestBase {
     host_manager_->BindAndSetManager(
         std::move(frame_sink_manager_client_request), nullptr,
         std::move(frame_sink_manager));
-    manager_impl_->BindAndSetClient(std::move(frame_sink_manager_request),
+    manager_impl_->BindAndSetClient(std::move(frame_sink_manager_receiver),
                                     nullptr,
                                     std::move(frame_sink_manager_client));
   }

components/viz/service/frame_sinks/frame_sink_manager_impl.cc

@@ -58,8 +58,7 @@ FrameSinkManagerImpl::FrameSinkManagerImpl(const InitParams& params)
       hit_test_manager_(surface_manager()),
       restart_id_(params.restart_id),
       run_all_compositor_stages_before_draw_(
-          params.run_all_compositor_stages_before_draw),
-      binding_(this) {
+          params.run_all_compositor_stages_before_draw) {
   surface_manager_.AddObserver(&hit_test_manager_);
   surface_manager_.AddObserver(this);
 }
@@ -86,12 +85,12 @@ FrameSinkManagerImpl::~FrameSinkManagerImpl() {
 }
 
 void FrameSinkManagerImpl::BindAndSetClient(
-    mojom::FrameSinkManagerRequest request,
+    mojo::PendingReceiver<mojom::FrameSinkManager> receiver,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     mojom::FrameSinkManagerClientPtr client) {
   DCHECK(!client_);
-  DCHECK(!binding_.is_bound());
-  binding_.Bind(std::move(request), std::move(task_runner));
+  DCHECK(!receiver_.is_bound());
+  receiver_.Bind(std::move(receiver), std::move(task_runner));
   client_ptr_ = std::move(client);
   client_ = client_ptr_.get();
 }
@@ -106,8 +105,8 @@ void FrameSinkManagerImpl::SetLocalClient(
 }
 
 void FrameSinkManagerImpl::ForceShutdown() {
-  if (binding_.is_bound())
-    binding_.Close();
+  if (receiver_.is_bound())
+    receiver_.reset();
 
   for (auto& it : cached_back_buffers_)
     it.second.RunAndReset();

components/viz/service/frame_sinks/frame_sink_manager_impl.h

@@ -34,7 +34,6 @@
 #include "components/viz/service/surfaces/surface_observer.h"
 #include "components/viz/service/viz_service_export.h"
 #include "gpu/ipc/common/surface_handle.h"
-#include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "services/viz/privileged/mojom/compositing/frame_sink_manager.mojom.h"
@@ -83,10 +82,10 @@ class VIZ_SERVICE_EXPORT FrameSinkManagerImpl
   // incoming IPCs and destroys all [Root]CompositorFrameSinkImpls.
   void ForceShutdown();
 
-  // Binds |this| as a FrameSinkManagerImpl for |request| on |task_runner|. On
+  // Binds |this| as a FrameSinkManagerImpl for |receiver| on |task_runner|. On
   // Mac |task_runner| will be the resize helper task runner. May only be called
   // once.
-  void BindAndSetClient(mojom::FrameSinkManagerRequest request,
+  void BindAndSetClient(mojo::PendingReceiver<mojom::FrameSinkManager> receiver,
                         scoped_refptr<base::SingleThreadTaskRunner> task_runner,
                         mojom::FrameSinkManagerClientPtr client);
 
@@ -349,7 +348,7 @@ class VIZ_SERVICE_EXPORT FrameSinkManagerImpl
   mojom::FrameSinkManagerClient* client_ = nullptr;
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_ = nullptr;
   mojom::FrameSinkManagerClientPtr client_ptr_;
-  mojo::Binding<mojom::FrameSinkManager> binding_;
+  mojo::Receiver<mojom::FrameSinkManager> receiver_{this};
 
   base::ObserverList<FrameSinkObserver>::Unchecked observer_list_;
 

components/viz/test/test_frame_sink_manager.cc

@@ -6,14 +6,14 @@
 
 namespace viz {
 
-TestFrameSinkManagerImpl::TestFrameSinkManagerImpl() : binding_(this) {}
+TestFrameSinkManagerImpl::TestFrameSinkManagerImpl() = default;
 
-TestFrameSinkManagerImpl::~TestFrameSinkManagerImpl() {}
+TestFrameSinkManagerImpl::~TestFrameSinkManagerImpl() = default;
 
-void TestFrameSinkManagerImpl::BindRequest(
-    mojom::FrameSinkManagerRequest request,
+void TestFrameSinkManagerImpl::BindReceiver(
+    mojo::PendingReceiver<mojom::FrameSinkManager> receiver,
     mojom::FrameSinkManagerClientPtr client) {
-  binding_.Bind(std::move(request));
+  receiver_.Bind(std::move(receiver));
   client_ = std::move(client);
 }
 

components/viz/test/test_frame_sink_manager.h

@@ -6,9 +6,9 @@
 #define COMPONENTS_VIZ_TEST_TEST_FRAME_SINK_MANAGER_H_
 
 #include "base/macros.h"
-#include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "services/viz/privileged/mojom/compositing/frame_sink_manager.mojom.h"
 
 namespace viz {
@@ -18,8 +18,8 @@ class TestFrameSinkManagerImpl : public mojom::FrameSinkManager {
   TestFrameSinkManagerImpl();
   ~TestFrameSinkManagerImpl() override;
 
-  void BindRequest(mojom::FrameSinkManagerRequest request,
-                   mojom::FrameSinkManagerClientPtr client);
+  void BindReceiver(mojo::PendingReceiver<mojom::FrameSinkManager> receiver,
+                    mojom::FrameSinkManagerClientPtr client);
 
  private:
   // mojom::FrameSinkManager:
@@ -63,7 +63,7 @@ class TestFrameSinkManagerImpl : public mojom::FrameSinkManager {
   void EvictBackBuffer(uint32_t cache_id,
                        EvictBackBufferCallback callback) override {}
 
-  mojo::Binding<mojom::FrameSinkManager> binding_;
+  mojo::Receiver<mojom::FrameSinkManager> receiver_{this};
   mojom::FrameSinkManagerClientPtr client_;
 
   DISALLOW_COPY_AND_ASSIGN(TestFrameSinkManagerImpl);

content/browser/compositor/test/test_image_transport_factory.cc

@@ -12,6 +12,8 @@
 #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h"
 #include "components/viz/test/test_frame_sink_manager.h"
 #include "content/browser/compositor/surface_utils.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "ui/compositor/reflector.h"
 #include "ui/compositor/test/in_process_context_provider.h"
 
@@ -40,9 +42,10 @@ TestImageTransportFactory::TestImageTransportFactory()
     test_frame_sink_manager_impl_ =
         std::make_unique<viz::TestFrameSinkManagerImpl>();
 
-    viz::mojom::FrameSinkManagerPtr frame_sink_manager;
-    viz::mojom::FrameSinkManagerRequest frame_sink_manager_request =
-        mojo::MakeRequest(&frame_sink_manager);
+    mojo::PendingRemote<viz::mojom::FrameSinkManager> frame_sink_manager;
+    mojo::PendingReceiver<viz::mojom::FrameSinkManager>
+        frame_sink_manager_receiver =
+            frame_sink_manager.InitWithNewPipeAndPassReceiver();
     viz::mojom::FrameSinkManagerClientPtr frame_sink_manager_client;
     viz::mojom::FrameSinkManagerClientRequest
         frame_sink_manager_client_request =
@@ -56,8 +59,8 @@ TestImageTransportFactory::TestImageTransportFactory()
     // Bind endpoints in TestFrameSinkManagerImpl. For non-tests there would be
     // a FrameSinkManagerImpl running in another process and these interface
     // endpoints would be bound there.
-    test_frame_sink_manager_impl_->BindRequest(
-        std::move(frame_sink_manager_request),
+    test_frame_sink_manager_impl_->BindReceiver(
+        std::move(frame_sink_manager_receiver),
         std::move(frame_sink_manager_client));
   } else {
     shared_bitmap_manager_ = std::make_unique<viz::ServerSharedBitmapManager>();

content/browser/compositor/viz_process_transport_factory.cc

@@ -34,6 +34,8 @@
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/raster_interface.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/viz/public/cpp/gpu/context_provider_command_buffer.h"
 #include "ui/base/ui_base_features.h"
 #include "ui/compositor/reflector.h"
@@ -127,9 +129,10 @@ VizProcessTransportFactory::~VizProcessTransportFactory() {
 }
 
 void VizProcessTransportFactory::ConnectHostFrameSinkManager() {
-  viz::mojom::FrameSinkManagerPtr frame_sink_manager;
-  viz::mojom::FrameSinkManagerRequest frame_sink_manager_request =
-      mojo::MakeRequest(&frame_sink_manager);
+  mojo::PendingRemote<viz::mojom::FrameSinkManager> frame_sink_manager;
+  mojo::PendingReceiver<viz::mojom::FrameSinkManager>
+      frame_sink_manager_receiver =
+          frame_sink_manager.InitWithNewPipeAndPassReceiver();
   viz::mojom::FrameSinkManagerClientPtr frame_sink_manager_client;
   viz::mojom::FrameSinkManagerClientRequest frame_sink_manager_client_request =
       mojo::MakeRequest(&frame_sink_manager_client);
@@ -144,7 +147,7 @@ void VizProcessTransportFactory::ConnectHostFrameSinkManager() {
     // Hop to the IO thread, then send the other side of interface to viz
     // process.
     auto connect_on_io_thread =
-        [](viz::mojom::FrameSinkManagerRequest request,
+        [](mojo::PendingReceiver<viz::mojom::FrameSinkManager> receiver,
            viz::mojom::FrameSinkManagerClientPtrInfo client) {
           // There should always be a GpuProcessHost instance, and GPU process,
           // for running the compositor thread. The exception is during shutdown
@@ -153,12 +156,12 @@ void VizProcessTransportFactory::ConnectHostFrameSinkManager() {
           auto* gpu_process_host = GpuProcessHost::Get();
           if (gpu_process_host) {
             gpu_process_host->gpu_host()->ConnectFrameSinkManager(
-                std::move(request), std::move(client));
+                std::move(receiver), std::move(client));
           }
         };
     base::PostTask(FROM_HERE, {BrowserThread::IO},
                    base::BindOnce(connect_on_io_thread,
-                                  std::move(frame_sink_manager_request),
+                                  std::move(frame_sink_manager_receiver),
                                   frame_sink_manager_client.PassInterface()));
   } else {
     DCHECK(!viz_compositor_thread_);
@@ -176,7 +179,7 @@ void VizProcessTransportFactory::ConnectHostFrameSinkManager() {
     params->use_activation_deadline = activation_deadline_in_frames.has_value();
     params->activation_deadline_in_frames =
         activation_deadline_in_frames.value_or(0u);
-    params->frame_sink_manager = std::move(frame_sink_manager_request);
+    params->frame_sink_manager = std::move(frame_sink_manager_receiver);
     params->frame_sink_manager_client =
         frame_sink_manager_client.PassInterface();
     viz_compositor_thread_->CreateFrameSinkManager(std::move(params));

content/browser/compositor/viz_process_transport_factory.h

@@ -13,7 +13,6 @@
 #include "components/viz/service/main/viz_compositor_thread_runner_impl.h"
 #include "content/browser/compositor/image_transport_factory.h"
 #include "gpu/command_buffer/common/context_result.h"
-#include "mojo/public/cpp/bindings/binding.h"
 #include "services/viz/privileged/mojom/compositing/frame_sink_manager.mojom.h"
 #include "services/viz/public/mojom/compositing/compositor_frame_sink.mojom.h"
 #include "ui/compositor/compositor.h"

content/browser/renderer_host/compositor_dependencies_android.cc

@@ -20,6 +20,7 @@
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 
 namespace content {
 
@@ -95,9 +96,10 @@ CompositorDependenciesAndroid::CompositorDependenciesAndroid()
 CompositorDependenciesAndroid::~CompositorDependenciesAndroid() = default;
 
 void CompositorDependenciesAndroid::CreateVizFrameSinkManager() {
-  viz::mojom::FrameSinkManagerPtr frame_sink_manager;
-  viz::mojom::FrameSinkManagerRequest frame_sink_manager_request =
-      mojo::MakeRequest(&frame_sink_manager);
+  mojo::PendingRemote<viz::mojom::FrameSinkManager> frame_sink_manager;
+  mojo::PendingReceiver<viz::mojom::FrameSinkManager>
+      frame_sink_manager_receiver =
+          frame_sink_manager.InitWithNewPipeAndPassReceiver();
   viz::mojom::FrameSinkManagerClientPtr frame_sink_manager_client;
   viz::mojom::FrameSinkManagerClientRequest frame_sink_manager_client_request =
       mojo::MakeRequest(&frame_sink_manager_client);
@@ -117,7 +119,7 @@ void CompositorDependenciesAndroid::CreateVizFrameSinkManager() {
   // connected to the GPU process.
   pending_connect_viz_on_io_thread_ = base::BindOnce(
       &CompositorDependenciesAndroid::ConnectVizFrameSinkManagerOnIOThread,
-      std::move(frame_sink_manager_request),
+      std::move(frame_sink_manager_receiver),
       frame_sink_manager_client.PassInterface());
 }
 
@@ -144,12 +146,12 @@ void CompositorDependenciesAndroid::TryEstablishVizConnectionIfNeeded() {
 // re-run when the request is deleted (goes out of scope).
 // static
 void CompositorDependenciesAndroid::ConnectVizFrameSinkManagerOnIOThread(
-    viz::mojom::FrameSinkManagerRequest request,
+    mojo::PendingReceiver<viz::mojom::FrameSinkManager> receiver,
     viz::mojom::FrameSinkManagerClientPtrInfo client) {
   auto* gpu_process_host = GpuProcessHost::Get();
   if (!gpu_process_host)
     return;
-  gpu_process_host->gpu_host()->ConnectFrameSinkManager(std::move(request),
+  gpu_process_host->gpu_host()->ConnectFrameSinkManager(std::move(receiver),
                                                         std::move(client));
 }
 

content/browser/renderer_host/compositor_dependencies_android.h

@@ -13,6 +13,7 @@
 #include "base/no_destructor.h"
 #include "components/viz/common/surfaces/frame_sink_id_allocator.h"
 #include "components/viz/host/host_frame_sink_manager.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "services/viz/privileged/mojom/compositing/frame_sink_manager.mojom.h"
 
 namespace cc {
@@ -50,7 +51,7 @@ class CompositorDependenciesAndroid {
   friend class base::NoDestructor<CompositorDependenciesAndroid>;
 
   static void ConnectVizFrameSinkManagerOnIOThread(
-      viz::mojom::FrameSinkManagerRequest request,
+      mojo::PendingReceiver<viz::mojom::FrameSinkManager> receiver,
       viz::mojom::FrameSinkManagerClientPtrInfo client);
 
   CompositorDependenciesAndroid();

services/viz/privileged/mojom/viz_main.mojom

@@ -24,7 +24,7 @@ struct FrameSinkManagerParams {
   uint32 activation_deadline_in_frames = 4;
 
   // Host to viz interface.
-  FrameSinkManager& frame_sink_manager;
+  pending_receiver<FrameSinkManager> frame_sink_manager;
 
   // Viz to host interface.
   FrameSinkManagerClient frame_sink_manager_client;