Migrate InterfaceFactory to new Mojo types further

This CL applies the new Mojo types to CreateMediaPlayerRenderer
and CreateFlingRenderer in InterfaceFactory interface.

  - Convert FooRequest to mojo::PendingReceiver.
  - Convert FooPtr to mojo::PendingRemote or mojo::Remote.
  - Replace MakeStrongBinding with MakeSelfOwnedReceiver.

Bug: 955171
Change-Id: I8dabcba8ebe6e53dd3a561d786c8bd5bf1edb257
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1880988
Commit-Queue: Gyuyoung Kim <gyuyoung@igalia.com>
Reviewed-by: Thomas Guilbert <tguilbert@chromium.org>
Reviewed-by: Ken Rockot <rockot@google.com>
Reviewed-by: Sam McNally <sammc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#709795}

content/browser/media/android/media_player_renderer.cc

@@ -38,14 +38,15 @@ MediaPlayerRenderer::MediaPlayerRenderer(
     int process_id,
     int routing_id,
     WebContents* web_contents,
-    RendererExtensionRequest renderer_extension_request,
-    ClientExtensionPtr client_extension_ptr)
-    : client_extension_(std::move(client_extension_ptr)),
+    mojo::PendingReceiver<RendererExtension> renderer_extension_receiver,
+    mojo::PendingRemote<ClientExtension> client_extension_remote)
+    : client_extension_(std::move(client_extension_remote)),
       render_process_id_(process_id),
       routing_id_(routing_id),
       has_error_(false),
       volume_(kDefaultVolume),
-      renderer_extension_binding_(this, std::move(renderer_extension_request)) {
+      renderer_extension_receiver_(this,
+                                   std::move(renderer_extension_receiver)) {
   DCHECK_EQ(static_cast<RenderFrameHostImpl*>(
                 RenderFrameHost::FromID(process_id, routing_id))
                 ->delegate()

content/browser/media/android/media_player_renderer.h

@@ -17,7 +17,10 @@
 #include "media/base/renderer.h"
 #include "media/base/renderer_client.h"
 #include "media/mojo/mojom/renderer_extensions.mojom.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 "mojo/public/cpp/bindings/remote.h"
 #include "url/gurl.h"
 
 namespace content {
@@ -36,20 +39,19 @@ class CONTENT_EXPORT MediaPlayerRenderer
       public media::mojom::MediaPlayerRendererExtension,
       public media::MediaPlayerBridge::Client {
  public:
-  using RendererExtensionRequest =
-      media::mojom::MediaPlayerRendererExtensionRequest;
-  using ClientExtensionPtr =
-      media::mojom::MediaPlayerRendererClientExtensionPtr;
+  using RendererExtension = media::mojom::MediaPlayerRendererExtension;
+  using ClientExtension = media::mojom::MediaPlayerRendererClientExtension;
 
   // Permits embedders to handle custom urls.
   static void RegisterMediaUrlInterceptor(
       media::MediaUrlInterceptor* media_url_interceptor);
 
-  MediaPlayerRenderer(int process_id,
-                      int routing_id,
-                      WebContents* web_contents,
-                      RendererExtensionRequest renderer_extension_request,
-                      ClientExtensionPtr client_extension_ptr);
+  MediaPlayerRenderer(
+      int process_id,
+      int routing_id,
+      WebContents* web_contents,
+      mojo::PendingReceiver<RendererExtension> renderer_extension_receiver,
+      mojo::PendingRemote<ClientExtension> client_extension_remote);
 
   ~MediaPlayerRenderer() override;
 
@@ -105,7 +107,7 @@ class CONTENT_EXPORT MediaPlayerRenderer
 
   void UpdateVolume();
 
-  ClientExtensionPtr client_extension_;
+  mojo::Remote<ClientExtension> client_extension_;
 
   // Identifiers to find the RenderFrameHost that created |this|.
   // NOTE: We store these IDs rather than a RenderFrameHost* because we do not
@@ -133,7 +135,7 @@ class CONTENT_EXPORT MediaPlayerRenderer
   MediaPlayerRendererWebContentsObserver* web_contents_observer_;
   float volume_;
 
-  mojo::Binding<MediaPlayerRendererExtension> renderer_extension_binding_;
+  mojo::Receiver<MediaPlayerRendererExtension> renderer_extension_receiver_;
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<MediaPlayerRenderer> weak_factory_{this};

content/browser/media/flinging_renderer.cc

@@ -18,7 +18,7 @@ namespace content {
 
 FlingingRenderer::FlingingRenderer(
     std::unique_ptr<media::FlingingController> controller,
-    ClientExtensionPtr client_extension)
+    mojo::PendingRemote<ClientExtension> client_extension)
     : client_extension_(std::move(client_extension)),
       controller_(std::move(controller)) {
   controller_->AddMediaStatusObserver(this);
@@ -32,7 +32,7 @@ FlingingRenderer::~FlingingRenderer() {
 std::unique_ptr<FlingingRenderer> FlingingRenderer::Create(
     RenderFrameHost* render_frame_host,
     const std::string& presentation_id,
-    ClientExtensionPtr client_extension) {
+    mojo::PendingRemote<ClientExtension> client_extension) {
   DVLOG(1) << __func__;
 
   ContentClient* content_client = GetContentClient();

content/browser/media/flinging_renderer.h

@@ -13,6 +13,8 @@
 #include "media/base/renderer.h"
 #include "media/base/renderer_client.h"
 #include "media/mojo/mojom/renderer_extensions.mojom.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "url/gurl.h"
 
 namespace content {
@@ -28,7 +30,7 @@ class RenderFrameHost;
 class CONTENT_EXPORT FlingingRenderer : public media::Renderer,
                                         media::MediaStatusObserver {
  public:
-  using ClientExtensionPtr = media::mojom::FlingingRendererClientExtensionPtr;
+  using ClientExtension = media::mojom::FlingingRendererClientExtension;
 
   // Helper method to create a FlingingRenderer from an already existing
   // presentation ID.
@@ -37,7 +39,7 @@ class CONTENT_EXPORT FlingingRenderer : public media::Renderer,
   static std::unique_ptr<FlingingRenderer> Create(
       RenderFrameHost* render_frame_host,
       const std::string& presentation_id,
-      ClientExtensionPtr client_extension);
+      mojo::PendingRemote<ClientExtension> client_extension);
 
   ~FlingingRenderer() override;
 
@@ -62,7 +64,7 @@ class CONTENT_EXPORT FlingingRenderer : public media::Renderer,
 
   explicit FlingingRenderer(
       std::unique_ptr<media::FlingingController> controller,
-      ClientExtensionPtr client_extension);
+      mojo::PendingRemote<ClientExtension> client_extension);
 
   void SetExpectedPlayState(PlayState state);
 
@@ -80,7 +82,7 @@ class CONTENT_EXPORT FlingingRenderer : public media::Renderer,
 
   media::RendererClient* client_;
 
-  ClientExtensionPtr client_extension_;
+  mojo::Remote<ClientExtension> client_extension_;
 
   std::unique_ptr<media::FlingingController> controller_;
 

content/browser/media/flinging_renderer_unittest.cc

@@ -10,6 +10,7 @@
 #include "base/version.h"
 #include "media/base/media_controller.h"
 #include "media/base/mock_filters.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -54,7 +55,7 @@ class FlingingRendererTest : public testing::Test {
 
     renderer_ = base::WrapUnique(new FlingingRenderer(
         std::unique_ptr<media::FlingingController>(flinging_controller_),
-        nullptr));
+        mojo::NullRemote()));
 
     renderer_->Initialize(nullptr, &renderer_client_, base::DoNothing());
   }

content/browser/media/media_interface_proxy.cc

@@ -190,8 +190,9 @@ void MediaInterfaceProxy::CreateCastRenderer(
 #if defined(OS_ANDROID)
 void MediaInterfaceProxy::CreateFlingingRenderer(
     const std::string& presentation_id,
-    media::mojom::FlingingRendererClientExtensionPtr client_extension,
-    media::mojom::RendererRequest request) {
+    mojo::PendingRemote<media::mojom::FlingingRendererClientExtension>
+        client_extension,
+    mojo::PendingReceiver<media::mojom::Renderer> receiver) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::unique_ptr<FlingingRenderer> flinging_renderer =
@@ -202,14 +203,15 @@ void MediaInterfaceProxy::CreateFlingingRenderer(
     return;
 
   media::MojoRendererService::Create(nullptr, std::move(flinging_renderer),
-                                     std::move(request));
+                                     std::move(receiver));
 }
 
 void MediaInterfaceProxy::CreateMediaPlayerRenderer(
-    media::mojom::MediaPlayerRendererClientExtensionPtr client_extension_ptr,
-    media::mojom::RendererRequest request,
-    media::mojom::MediaPlayerRendererExtensionRequest
-        renderer_extension_request) {
+    mojo::PendingRemote<media::mojom::MediaPlayerRendererClientExtension>
+        client_extension_remote,
+    mojo::PendingReceiver<media::mojom::Renderer> receiver,
+    mojo::PendingReceiver<media::mojom::MediaPlayerRendererExtension>
+        renderer_extension_receiver) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   media::MojoRendererService::Create(
@@ -220,9 +222,9 @@ void MediaInterfaceProxy::CreateMediaPlayerRenderer(
           static_cast<RenderFrameHostImpl*>(render_frame_host_)
               ->delegate()
               ->GetAsWebContents(),
-          std::move(renderer_extension_request),
-          std::move(client_extension_ptr)),
-      std::move(request));
+          std::move(renderer_extension_receiver),
+          std::move(client_extension_remote)),
+      std::move(receiver));
 }
 #endif
 

content/browser/media/media_interface_proxy.h

@@ -65,12 +65,14 @@ class MediaInterfaceProxy : public media::mojom::InterfaceFactory {
 #if defined(OS_ANDROID)
   void CreateFlingingRenderer(
       const std::string& presentation_id,
-      media::mojom::FlingingRendererClientExtensionPtr client_extension,
-      media::mojom::RendererRequest request) final;
+      mojo::PendingRemote<media::mojom::FlingingRendererClientExtension>
+          client_extension,
+      mojo::PendingReceiver<media::mojom::Renderer> receiver) final;
   void CreateMediaPlayerRenderer(
-      media::mojom::MediaPlayerRendererClientExtensionPtr client_extension_ptr,
-      media::mojom::RendererRequest request,
-      media::mojom::MediaPlayerRendererExtensionRequest
+      mojo::PendingRemote<media::mojom::MediaPlayerRendererClientExtension>
+          client_extension_remote,
+      mojo::PendingReceiver<media::mojom::Renderer> receiver,
+      mojo::PendingReceiver<media::mojom::MediaPlayerRendererExtension>
           renderer_extension_request) final;
 #endif  // defined(OS_ANDROID)
   void CreateCdm(const std::string& key_system,

content/browser/media/video_decoder_proxy.cc

@@ -55,14 +55,16 @@ void VideoDecoderProxy::CreateCastRenderer(
 #if defined(OS_ANDROID)
 void VideoDecoderProxy::CreateFlingingRenderer(
     const std::string& audio_device_id,
-    media::mojom::FlingingRendererClientExtensionPtr client_extenion,
-    media::mojom::RendererRequest request) {}
+    mojo::PendingRemote<media::mojom::FlingingRendererClientExtension>
+        client_extenion,
+    mojo::PendingReceiver<media::mojom::Renderer> receiver) {}
 
 void VideoDecoderProxy::CreateMediaPlayerRenderer(
-    media::mojom::MediaPlayerRendererClientExtensionPtr client_extension_ptr,
-    media::mojom::RendererRequest request,
-    media::mojom::MediaPlayerRendererExtensionRequest
-        renderer_extension_request) {}
+    mojo::PendingRemote<media::mojom::MediaPlayerRendererClientExtension>
+        client_extension_remote,
+    mojo::PendingReceiver<media::mojom::Renderer> receiver,
+    mojo::PendingReceiver<media::mojom::MediaPlayerRendererExtension>
+        renderer_extension_receiver) {}
 #endif  // defined(OS_ANDROID)
 
 void VideoDecoderProxy::CreateCdm(

content/browser/media/video_decoder_proxy.h

@@ -46,14 +46,16 @@ class CONTENT_EXPORT VideoDecoderProxy : public media::mojom::InterfaceFactory {
 #endif
 #if defined(OS_ANDROID)
   void CreateMediaPlayerRenderer(
-      media::mojom::MediaPlayerRendererClientExtensionPtr client_extension_ptr,
-      media::mojom::RendererRequest request,
-      media::mojom::MediaPlayerRendererExtensionRequest
-          renderer_extension_request) final;
+      mojo::PendingRemote<media::mojom::MediaPlayerRendererClientExtension>
+          client_extension_remote,
+      mojo::PendingReceiver<media::mojom::Renderer> receiver,
+      mojo::PendingReceiver<media::mojom::MediaPlayerRendererExtension>
+          renderer_extension_receiver) final;
   void CreateFlingingRenderer(
       const std::string& presentation_id,
-      media::mojom::FlingingRendererClientExtensionPtr client_extension,
-      media::mojom::RendererRequest request) final;
+      mojo::PendingRemote<media::mojom::FlingingRendererClientExtension>
+          client_extension,
+      mojo::PendingReceiver<media::mojom::Renderer> receiver) final;
 #endif  // defined(OS_ANDROID)
   void CreateCdm(const std::string& key_system,
                  media::mojom::ContentDecryptionModuleRequest request) final;

content/renderer/media/android/flinging_renderer_client_factory.cc

@@ -13,6 +13,7 @@
 #include "media/mojo/clients/mojo_renderer.h"
 #include "media/mojo/clients/mojo_renderer_factory.h"
 #include "media/mojo/mojom/renderer_extensions.mojom.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 
 namespace content {
 
@@ -36,16 +37,18 @@ std::unique_ptr<media::Renderer> FlingingRendererClientFactory::CreateRenderer(
 
   // Used to send messages from the FlingingRenderer (Browser process),
   // to the FlingingRendererClient (Renderer process). The
-  // |client_extension_request| will be bound in FlingingRendererClient.
-  media::mojom::FlingingRendererClientExtensionPtr client_extension_ptr;
-  auto client_extension_request = mojo::MakeRequest(&client_extension_ptr);
+  // |client_extension_receiver| will be bound in FlingingRendererClient.
+  mojo::PendingRemote<media::mojom::FlingingRendererClientExtension>
+      client_extension_remote;
+  auto client_extension_receiver =
+      client_extension_remote.InitWithNewPipeAndPassReceiver();
 
   auto mojo_renderer = mojo_flinging_factory_->CreateFlingingRenderer(
-      GetActivePresentationId(), std::move(client_extension_ptr),
+      GetActivePresentationId(), std::move(client_extension_remote),
       media_task_runner, video_renderer_sink);
 
   return std::make_unique<FlingingRendererClient>(
-      std::move(client_extension_request), media_task_runner,
+      std::move(client_extension_receiver), media_task_runner,
       std::move(mojo_renderer), remote_play_state_change_cb_);
 }
 

content/renderer/media/android/media_player_renderer_client.cc

@@ -11,8 +11,8 @@
 namespace content {
 
 MediaPlayerRendererClient::MediaPlayerRendererClient(
-    RendererExtentionPtr renderer_extension_ptr,
-    ClientExtentionRequest client_extension_request,
+    mojo::PendingRemote<RendererExtention> renderer_extension_remote,
+    mojo::PendingReceiver<ClientExtention> client_extension_receiver,
     scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
     std::unique_ptr<media::MojoRenderer> mojo_renderer,
@@ -24,11 +24,10 @@ MediaPlayerRendererClient::MediaPlayerRendererClient(
       sink_(sink),
       media_task_runner_(std::move(media_task_runner)),
       compositor_task_runner_(std::move(compositor_task_runner)),
-      delayed_bind_client_extension_request_(
-          std::move(client_extension_request)),
-      delayed_bind_renderer_extention_ptr_info_(
-          renderer_extension_ptr.PassInterface()),
-      client_extension_binding_(this) {}
+      delayed_bind_client_extension_receiver_(
+          std::move(client_extension_receiver)),
+      delayed_bind_renderer_extention_remote_(
+          std::move(renderer_extension_remote)) {}
 
 MediaPlayerRendererClient::~MediaPlayerRendererClient() {
   // Clearing the STW's callback into |this| must happen first. Otherwise, the
@@ -45,12 +44,12 @@ void MediaPlayerRendererClient::Initialize(
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DCHECK(!init_cb_);
 
-  // Consume and bind the delayed Request and PtrInfo now that we are on
-  // |media_task_runner_|.
-  renderer_extension_ptr_.Bind(
-      std::move(delayed_bind_renderer_extention_ptr_info_), media_task_runner_);
-  client_extension_binding_.Bind(
-      std::move(delayed_bind_client_extension_request_), media_task_runner_);
+  // Consume and bind the delayed PendingRemote and PendingReceiver now that we
+  // are on |media_task_runner_|.
+  renderer_extension_remote_.Bind(
+      std::move(delayed_bind_renderer_extention_remote_), media_task_runner_);
+  client_extension_receiver_.Bind(
+      std::move(delayed_bind_client_extension_receiver_), media_task_runner_);
 
   media_resource_ = media_resource;
   client_ = client;
@@ -112,7 +111,7 @@ void MediaPlayerRendererClient::OnRemoteRendererInitialized(
   if (status == media::PIPELINE_OK) {
     // TODO(tguilbert): Measure and smooth out the initialization's ordering to
     // have the lowest total initialization time.
-    renderer_extension_ptr_->InitiateScopedSurfaceRequest(
+    renderer_extension_remote_->InitiateScopedSurfaceRequest(
         base::Bind(&MediaPlayerRendererClient::OnScopedSurfaceRequested,
                    weak_factory_.GetWeakPtr()));
 

content/renderer/media/android/media_player_renderer_client.h

@@ -20,7 +20,10 @@
 #include "media/mojo/clients/mojo_renderer.h"
 #include "media/mojo/clients/mojo_renderer_wrapper.h"
 #include "media/mojo/mojom/renderer_extensions.mojom.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 "mojo/public/cpp/bindings/remote.h"
 
 namespace content {
 
@@ -38,15 +41,12 @@ class CONTENT_EXPORT MediaPlayerRendererClient
     : public media::mojom::MediaPlayerRendererClientExtension,
       public media::MojoRendererWrapper {
  public:
-  using RendererExtentionPtr = media::mojom::MediaPlayerRendererExtensionPtr;
-  using RendererExtentionPtrInfo =
-      media::mojom::MediaPlayerRendererExtensionPtrInfo;
-  using ClientExtentionRequest =
-      media::mojom::MediaPlayerRendererClientExtensionRequest;
+  using RendererExtention = media::mojom::MediaPlayerRendererExtension;
+  using ClientExtention = media::mojom::MediaPlayerRendererClientExtension;
 
   MediaPlayerRendererClient(
-      RendererExtentionPtr renderer_extension_ptr,
-      ClientExtentionRequest client_extension_request,
+      mojo::PendingRemote<RendererExtention> renderer_extension_remote,
+      mojo::PendingReceiver<ClientExtention> client_extension_receiver,
       scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
       std::unique_ptr<media::MojoRenderer> mojo_renderer,
@@ -104,14 +104,17 @@ class CONTENT_EXPORT MediaPlayerRendererClient
   // |renderer_extension_ptr_| and |client_extension_binding_|, until we are on
   // |media_task_runner_|.
   // Both are set in the constructor, and consumed in Initialize().
-  ClientExtentionRequest delayed_bind_client_extension_request_;
-  RendererExtentionPtrInfo delayed_bind_renderer_extention_ptr_info_;
+  mojo::PendingReceiver<ClientExtention>
+      delayed_bind_client_extension_receiver_;
+  mojo::PendingRemote<RendererExtention>
+      delayed_bind_renderer_extention_remote_;
 
   // Used to call methods on the MediaPlayerRenderer in the browser process.
-  RendererExtentionPtr renderer_extension_ptr_;
+  mojo::Remote<RendererExtention> renderer_extension_remote_;
 
   // Used to receive events from MediaPlayerRenderer in the browser process.
-  mojo::Binding<MediaPlayerRendererClientExtension> client_extension_binding_;
+  mojo::Receiver<MediaPlayerRendererClientExtension> client_extension_receiver_{
+      this};
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<MediaPlayerRendererClient> weak_factory_{this};

content/renderer/media/android/media_player_renderer_client_factory.cc

@@ -32,27 +32,32 @@ MediaPlayerRendererClientFactory::CreateRenderer(
   // Used to send messages from the MPRC (Renderer process), to the MPR (Browser
   // process). The |renderer_extension_request| will be bound in
   // MediaPlayerRenderer.
-  media::mojom::MediaPlayerRendererExtensionPtr renderer_extension_ptr;
-  auto renderer_extension_request = mojo::MakeRequest(&renderer_extension_ptr);
+  mojo::PendingRemote<media::mojom::MediaPlayerRendererExtension>
+      renderer_extension_remote;
+  auto renderer_extension_receiver =
+      renderer_extension_remote.InitWithNewPipeAndPassReceiver();
 
   // Used to send messages from the MPR (Browser process), to the MPRC (Renderer
   // process). The |client_extension_request| will be bound in
   // MediaPlayerRendererClient.
-  media::mojom::MediaPlayerRendererClientExtensionPtr client_extension_ptr;
-  auto client_extension_request = mojo::MakeRequest(&client_extension_ptr);
+  mojo::PendingRemote<media::mojom::MediaPlayerRendererClientExtension>
+      client_extension_remote;
+  auto client_extension_receiver =
+      client_extension_remote.InitWithNewPipeAndPassReceiver();
 
   std::unique_ptr<media::MojoRenderer> mojo_renderer =
       mojo_renderer_factory_->CreateMediaPlayerRenderer(
-          std::move(renderer_extension_request),
-          std::move(client_extension_ptr), media_task_runner,
+          std::move(renderer_extension_receiver),
+          std::move(client_extension_remote), media_task_runner,
           video_renderer_sink);
 
   media::ScopedStreamTextureWrapper stream_texture_wrapper =
       get_stream_texture_wrapper_cb_.Run();
 
   return std::make_unique<MediaPlayerRendererClient>(
-      std::move(renderer_extension_ptr), std::move(client_extension_request),
-      media_task_runner, compositor_task_runner_, std::move(mojo_renderer),
+      std::move(renderer_extension_remote),
+      std::move(client_extension_receiver), media_task_runner,
+      compositor_task_runner_, std::move(mojo_renderer),
       std::move(stream_texture_wrapper), video_renderer_sink);
 }
 

content/renderer/media/media_interface_factory.cc

@@ -88,42 +88,44 @@ void MediaInterfaceFactory::CreateCastRenderer(
 
 #if defined(OS_ANDROID)
 void MediaInterfaceFactory::CreateMediaPlayerRenderer(
-    media::mojom::MediaPlayerRendererClientExtensionPtr client_extension_ptr,
-    media::mojom::RendererRequest request,
-    media::mojom::MediaPlayerRendererExtensionRequest
-        renderer_extension_request) {
+    mojo::PendingRemote<media::mojom::MediaPlayerRendererClientExtension>
+        client_extension_remote,
+    mojo::PendingReceiver<media::mojom::Renderer> receiver,
+    mojo::PendingReceiver<media::mojom::MediaPlayerRendererExtension>
+        renderer_extension_receiver) {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&MediaInterfaceFactory::CreateMediaPlayerRenderer,
-                       weak_this_, std::move(client_extension_ptr),
-                       std::move(request),
-                       std::move(renderer_extension_request)));
+                       weak_this_, std::move(client_extension_remote),
+                       std::move(receiver),
+                       std::move(renderer_extension_receiver)));
     return;
   }
 
   DVLOG(1) << __func__;
   GetMediaInterfaceFactory()->CreateMediaPlayerRenderer(
-      std::move(client_extension_ptr), std::move(request),
-      std::move(renderer_extension_request));
+      std::move(client_extension_remote), std::move(receiver),
+      std::move(renderer_extension_receiver));
 }
 
 void MediaInterfaceFactory::CreateFlingingRenderer(
     const std::string& presentation_id,
-    media::mojom::FlingingRendererClientExtensionPtr client_extension,
-    media::mojom::RendererRequest request) {
+    mojo::PendingRemote<media::mojom::FlingingRendererClientExtension>
+        client_extension,
+    mojo::PendingReceiver<media::mojom::Renderer> receiver) {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&MediaInterfaceFactory::CreateFlingingRenderer,
                        weak_this_, presentation_id, std::move(client_extension),
-                       std::move(request)));
+                       std::move(receiver)));
     return;
   }
 
   DVLOG(1) << __func__;
   GetMediaInterfaceFactory()->CreateFlingingRenderer(
-      presentation_id, std::move(client_extension), std::move(request));
+      presentation_id, std::move(client_extension), std::move(receiver));
 }
 #endif  // defined(OS_ANDROID)
 

content/renderer/media/media_interface_factory.h

@@ -15,6 +15,7 @@
 #include "media/mojo/buildflags.h"
 #include "media/mojo/mojom/interface_factory.mojom.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "url/gurl.h"
 
 namespace service_manager {
@@ -48,13 +49,15 @@ class CONTENT_EXPORT MediaInterfaceFactory
 #if defined(OS_ANDROID)
   void CreateFlingingRenderer(
       const std::string& presentation_id,
-      media::mojom::FlingingRendererClientExtensionPtr client_extension,
-      media::mojom::RendererRequest request) final;
+      mojo::PendingRemote<media::mojom::FlingingRendererClientExtension>
+          client_extension,
+      mojo::PendingReceiver<media::mojom::Renderer> receiver) final;
   void CreateMediaPlayerRenderer(
-      media::mojom::MediaPlayerRendererClientExtensionPtr client_extension_ptr,
-      media::mojom::RendererRequest request,
-      media::mojom::MediaPlayerRendererExtensionRequest
-          renderer_extension_request) final;
+      mojo::PendingRemote<media::mojom::MediaPlayerRendererClientExtension>
+          client_extension_remote,
+      mojo::PendingReceiver<media::mojom::Renderer> receiver,
+      mojo::PendingReceiver<media::mojom::MediaPlayerRendererExtension>
+          renderer_extension_receiver) final;
 #endif  // defined(OS_ANDROID)
   void CreateCdm(const std::string& key_system,
                  media::mojom::ContentDecryptionModuleRequest request) final;

media/mojo/clients/mojo_renderer.cc

@@ -24,11 +24,11 @@ MojoRenderer::MojoRenderer(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     std::unique_ptr<VideoOverlayFactory> video_overlay_factory,
     VideoRendererSink* video_renderer_sink,
-    mojom::RendererPtr remote_renderer)
+    mojo::PendingRemote<mojom::Renderer> remote_renderer)
     : task_runner_(task_runner),
       video_overlay_factory_(std::move(video_overlay_factory)),
       video_renderer_sink_(video_renderer_sink),
-      remote_renderer_info_(remote_renderer.PassInterface()),
+      remote_renderer_pending_remote_(std::move(remote_renderer)),
       client_binding_(this),
       media_time_interpolator_(base::DefaultTickClock::GetInstance()) {
   DVLOG(1) << __func__;
@@ -336,14 +336,14 @@ void MojoRenderer::BindRemoteRendererIfNeeded() {
   if (remote_renderer_.is_bound())
     return;
 
-  // Bind |remote_renderer_| to the |task_runner_|.
-  remote_renderer_.Bind(std::move(remote_renderer_info_));
+  // Bind |remote_renderer_| to the |remote_renderer_pending_remote_|.
+  remote_renderer_.Bind(std::move(remote_renderer_pending_remote_));
 
   // Otherwise, set an error handler to catch the connection error.
   // Using base::Unretained(this) is safe because |this| owns
   // |remote_renderer_|, and the error handler can't be invoked once
   // |remote_renderer_| is destroyed.
-  remote_renderer_.set_connection_error_handler(
+  remote_renderer_.set_disconnect_handler(
       base::Bind(&MojoRenderer::OnConnectionError, base::Unretained(this)));
 }
 

media/mojo/clients/mojo_renderer.h

@@ -19,6 +19,8 @@
 #include "media/base/time_delta_interpolator.h"
 #include "media/mojo/mojom/renderer.mojom.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace base {
 class SingleThreadTaskRunner;
@@ -46,7 +48,7 @@ class MojoRenderer : public Renderer, public mojom::RendererClient {
   MojoRenderer(const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
                std::unique_ptr<VideoOverlayFactory> video_overlay_factory,
                VideoRendererSink* video_renderer_sink,
-               mojom::RendererPtr remote_renderer);
+               mojo::PendingRemote<mojom::Renderer> remote_renderer);
   ~MojoRenderer() override;
 
   // Renderer implementation.
@@ -133,12 +135,13 @@ class MojoRenderer : public Renderer, public mojom::RendererClient {
   std::vector<std::unique_ptr<MojoDemuxerStreamImpl>> streams_;
 
   // This class is constructed on one thread and used exclusively on another
-  // thread. This member is used to safely pass the RendererPtr from one thread
-  // to another. It is set in the constructor and is consumed in Initialize().
-  mojom::RendererPtrInfo remote_renderer_info_;
+  // thread. This member is used to safely pass the PendingRemote from one
+  // thread to another. It is set in the constructor and is consumed in
+  // Initialize().
+  mojo::PendingRemote<mojom::Renderer> remote_renderer_pending_remote_;
 
   // Remote Renderer, bound to |task_runner_| during Initialize().
-  mojom::RendererPtr remote_renderer_;
+  mojo::Remote<mojom::Renderer> remote_renderer_;
 
   // Binding for RendererClient, bound to the |task_runner_|.
   mojo::AssociatedBinding<RendererClient> client_binding_;

media/mojo/clients/mojo_renderer_factory.cc

@@ -13,6 +13,7 @@
 #include "media/renderers/decrypting_renderer.h"
 #include "media/renderers/video_overlay_factory.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/service_manager/public/cpp/connect.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 
@@ -37,13 +38,13 @@ std::unique_ptr<Renderer> MojoRendererFactory::CreateRenderer(
 
   auto overlay_factory = std::make_unique<VideoOverlayFactory>();
 
-  mojom::RendererPtr renderer_ptr;
-  interface_factory_->CreateDefaultRenderer(std::string(),
-                                            mojo::MakeRequest(&renderer_ptr));
+  mojo::PendingRemote<mojom::Renderer> renderer_remote;
+  interface_factory_->CreateDefaultRenderer(
+      std::string(), renderer_remote.InitWithNewPipeAndPassReceiver());
 
   return std::make_unique<MojoRenderer>(
       media_task_runner, std::move(overlay_factory), video_renderer_sink,
-      std::move(renderer_ptr));
+      std::move(renderer_remote));
 }
 
 #if BUILDFLAG(ENABLE_CAST_RENDERER)
@@ -54,47 +55,54 @@ std::unique_ptr<MojoRenderer> MojoRendererFactory::CreateCastRenderer(
 
   auto overlay_factory = std::make_unique<VideoOverlayFactory>();
 
-  mojom::RendererPtr renderer_ptr;
-  interface_factory_->CreateCastRenderer(overlay_factory->overlay_plane_id(),
-                                         mojo::MakeRequest(&renderer_ptr));
+  mojo::PendingRemote<mojom::Renderer> renderer_remote;
+  interface_factory_->CreateCastRenderer(
+      overlay_factory->overlay_plane_id(),
+      renderer_remote.InitWithNewPipeAndPassReceiver());
 
   return std::make_unique<MojoRenderer>(
       media_task_runner, std::move(overlay_factory), video_renderer_sink,
-      std::move(renderer_ptr));
+      std::move(renderer_remote));
 }
 #endif  // BUILDFLAG(ENABLE_CAST_RENDERER)
 
 #if defined(OS_ANDROID)
 std::unique_ptr<MojoRenderer> MojoRendererFactory::CreateFlingingRenderer(
     const std::string& presentation_id,
-    mojom::FlingingRendererClientExtensionPtr client_extension_ptr,
+    mojo::PendingRemote<mojom::FlingingRendererClientExtension>
+        client_extension_remote,
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     VideoRendererSink* video_renderer_sink) {
   DCHECK(interface_factory_);
-  mojom::RendererPtr renderer_ptr;
+  mojo::PendingRemote<mojom::Renderer> renderer_remote;
 
-  interface_factory_->CreateFlingingRenderer(presentation_id,
-                                             std::move(client_extension_ptr),
-                                             mojo::MakeRequest(&renderer_ptr));
+  interface_factory_->CreateFlingingRenderer(
+      presentation_id, std::move(client_extension_remote),
+      renderer_remote.InitWithNewPipeAndPassReceiver());
 
-  return std::make_unique<MojoRenderer>(
-      media_task_runner, nullptr, video_renderer_sink, std::move(renderer_ptr));
+  return std::make_unique<MojoRenderer>(media_task_runner, nullptr,
+                                        video_renderer_sink,
+                                        std::move(renderer_remote));
 }
 
 std::unique_ptr<MojoRenderer> MojoRendererFactory::CreateMediaPlayerRenderer(
-    mojom::MediaPlayerRendererExtensionRequest renderer_extension_request,
-    mojom::MediaPlayerRendererClientExtensionPtr client_extension_ptr,
+    mojo::PendingReceiver<mojom::MediaPlayerRendererExtension>
+        renderer_extension_receiver,
+    mojo::PendingRemote<mojom::MediaPlayerRendererClientExtension>
+        client_extension_remote,
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     VideoRendererSink* video_renderer_sink) {
   DCHECK(interface_factory_);
-  mojom::RendererPtr renderer_ptr;
+  mojo::PendingRemote<mojom::Renderer> renderer_remote;
 
   interface_factory_->CreateMediaPlayerRenderer(
-      std::move(client_extension_ptr), mojo::MakeRequest(&renderer_ptr),
-      std::move(renderer_extension_request));
+      std::move(client_extension_remote),
+      renderer_remote.InitWithNewPipeAndPassReceiver(),
+      std::move(renderer_extension_receiver));
 
-  return std::make_unique<MojoRenderer>(
-      media_task_runner, nullptr, video_renderer_sink, std::move(renderer_ptr));
+  return std::make_unique<MojoRenderer>(media_task_runner, nullptr,
+                                        video_renderer_sink,
+                                        std::move(renderer_remote));
 }
 #endif  // defined(OS_ANDROID)
 

media/mojo/clients/mojo_renderer_factory.h

@@ -14,6 +14,8 @@
 #include "media/mojo/buildflags.h"
 #include "media/mojo/mojom/interface_factory.mojom.h"
 #include "media/mojo/mojom/renderer.mojom.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 
 namespace service_manager {
 class InterfaceProvider;
@@ -57,13 +59,16 @@ class MojoRendererFactory : public RendererFactory {
 #if defined(OS_ANDROID)
   std::unique_ptr<MojoRenderer> CreateFlingingRenderer(
       const std::string& presentation_id,
-      mojom::FlingingRendererClientExtensionPtr client_extenion_ptr,
+      mojo::PendingRemote<mojom::FlingingRendererClientExtension>
+          client_extenion_ptr,
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       VideoRendererSink* video_renderer_sink);
 
   std::unique_ptr<MojoRenderer> CreateMediaPlayerRenderer(
-      mojom::MediaPlayerRendererExtensionRequest renderer_extension_request,
-      mojom::MediaPlayerRendererClientExtensionPtr client_extension_ptr,
+      mojo::PendingReceiver<mojom::MediaPlayerRendererExtension>
+          renderer_extension_receiver,
+      mojo::PendingRemote<mojom::MediaPlayerRendererClientExtension>
+          client_extension_remote,
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       VideoRendererSink* video_renderer_sink);
 #endif  // defined (OS_ANDROID)

media/mojo/clients/mojo_renderer_unittest.cc

@@ -27,6 +27,7 @@
 #include "media/mojo/services/mojo_renderer_service.h"
 #include "media/renderers/video_overlay_factory.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
@@ -70,15 +71,15 @@ class MojoRendererTest : public ::testing::Test {
         new StrictMock<MockRenderer>());
     mock_renderer_ = mock_renderer.get();
 
-    mojom::RendererPtr remote_renderer;
+    mojo::PendingRemote<mojom::Renderer> remote_renderer_remote;
     renderer_binding_ = MojoRendererService::Create(
         &mojo_cdm_service_context_, std::move(mock_renderer),
-        mojo::MakeRequest(&remote_renderer));
+        remote_renderer_remote.InitWithNewPipeAndPassReceiver());
 
     mojo_renderer_.reset(
         new MojoRenderer(message_loop_.task_runner(),
                          std::unique_ptr<VideoOverlayFactory>(nullptr), nullptr,
-                         std::move(remote_renderer)));
+                         std::move(remote_renderer_remote)));
 
     // CreateAudioStream() and CreateVideoStream() overrides expectations for
     // expected non-NULL streams.

media/mojo/mojom/interface_factory.mojom

@@ -43,17 +43,19 @@ interface InterfaceFactory {
   //   from MediaPlayerRendererClient.
   // - |client_extension| is bound in MediaPlayerRendererClient, and receives
   //   calls from the MediaPlayerRenderer.
-  CreateMediaPlayerRenderer(MediaPlayerRendererClientExtension client_extension,
-                            Renderer& renderer,
-                            MediaPlayerRendererExtension& renderer_extension);
+  CreateMediaPlayerRenderer(
+      pending_remote<MediaPlayerRendererClientExtension> client_extension,
+      pending_receiver<Renderer> renderer,
+      pending_receiver<MediaPlayerRendererExtension> renderer_extension);
 
   [EnableIf=is_android]
   // Creates a FlingingRenderer (FlingingRendererFactory).
   // The |presentation_id| is used to find an already set-up RemotePlayback
   // session (see blink::RemotePlayback).
-  CreateFlingingRenderer(string presentation_id,
-                         FlingingRendererClientExtension client_extension,
-                         Renderer& renderer);
+  CreateFlingingRenderer(
+      string presentation_id,
+      pending_remote<FlingingRendererClientExtension> client_extension,
+      pending_receiver<Renderer> renderer);
 
   // Creates a CDM based on the |key_system| provided. A |key_system| is a
   // generic term for a decryption mechanism and/or content protection provider.

media/mojo/services/interface_factory_impl.cc

@@ -157,16 +157,19 @@ void InterfaceFactoryImpl::CreateCastRenderer(
 
 #if defined(OS_ANDROID)
 void InterfaceFactoryImpl::CreateMediaPlayerRenderer(
-    mojom::MediaPlayerRendererClientExtensionPtr client_extension_ptr,
-    mojom::RendererRequest request,
-    mojom::MediaPlayerRendererExtensionRequest renderer_extension_request) {
+    mojo::PendingRemote<mojom::MediaPlayerRendererClientExtension>
+        client_extension_ptr,
+    mojo::PendingReceiver<mojom::Renderer> receiver,
+    mojo::PendingReceiver<mojom::MediaPlayerRendererExtension>
+        renderer_extension_receiver) {
   NOTREACHED();
 }
 
 void InterfaceFactoryImpl::CreateFlingingRenderer(
     const std::string& audio_device_id,
-    mojom::FlingingRendererClientExtensionPtr client_extension,
-    mojo::InterfaceRequest<mojom::Renderer> request) {
+    mojo::PendingRemote<mojom::FlingingRendererClientExtension>
+        client_extension,
+    mojo::PendingReceiver<mojom::Renderer> receiver) {
   NOTREACHED();
 }
 #endif  // defined(OS_ANDROID)

media/mojo/services/interface_factory_impl.h

@@ -56,14 +56,16 @@ class InterfaceFactoryImpl : public DeferredDestroy<mojom::InterfaceFactory> {
 #endif
 #if defined(OS_ANDROID)
   void CreateMediaPlayerRenderer(
-      mojom::MediaPlayerRendererClientExtensionPtr client_extension_ptr,
-      mojom::RendererRequest request,
-      mojom::MediaPlayerRendererExtensionRequest renderer_extension_request)
-      final;
+      mojo::PendingRemote<mojom::MediaPlayerRendererClientExtension>
+          client_extension_remote,
+      mojo::PendingReceiver<mojom::Renderer> receiver,
+      mojo::PendingReceiver<mojom::MediaPlayerRendererExtension>
+          renderer_extension_receiver) final;
   void CreateFlingingRenderer(
       const std::string& presentation_id,
-      mojom::FlingingRendererClientExtensionPtr client_extension,
-      mojom::RendererRequest request) final;
+      mojo::PendingRemote<mojom::FlingingRendererClientExtension>
+          client_extension,
+      mojo::PendingReceiver<mojom::Renderer> receiver) final;
 #endif  // defined(OS_ANDROID)
   void CreateCdm(const std::string& key_system,
                  mojom::ContentDecryptionModuleRequest request) final;

media/mojo/services/mojo_renderer_service.cc

@@ -15,6 +15,7 @@
 #include "media/mojo/common/media_type_converters.h"
 #include "media/mojo/services/media_resource_shim.h"
 #include "media/mojo/services/mojo_cdm_service_context.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
 
 namespace media {
 
@@ -35,13 +36,13 @@ const int kTimeUpdateIntervalMs = 50;
 mojo::StrongBindingPtr<mojom::Renderer> MojoRendererService::Create(
     MojoCdmServiceContext* mojo_cdm_service_context,
     std::unique_ptr<media::Renderer> renderer,
-    mojo::InterfaceRequest<mojom::Renderer> request) {
+    mojo::PendingReceiver<mojom::Renderer> receiver) {
   MojoRendererService* service =
       new MojoRendererService(mojo_cdm_service_context, std::move(renderer));
 
   mojo::StrongBindingPtr<mojom::Renderer> binding =
-      mojo::MakeStrongBinding<mojom::Renderer>(base::WrapUnique(service),
-                                               std::move(request));
+      mojo::MakeSelfOwnedReceiver<mojom::Renderer>(base::WrapUnique(service),
+                                                   std::move(receiver));
 
   service->set_bad_message_cb(base::Bind(&CloseBindingOnBadMessage, binding));
 

media/mojo/services/mojo_renderer_service.h

@@ -21,6 +21,7 @@
 #include "media/base/renderer_client.h"
 #include "media/mojo/mojom/renderer.mojom.h"
 #include "media/mojo/services/media_mojo_export.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 
 namespace media {
@@ -40,7 +41,7 @@ class MEDIA_MOJO_EXPORT MojoRendererService : public mojom::Renderer,
   static mojo::StrongBindingPtr<mojom::Renderer> Create(
       MojoCdmServiceContext* mojo_cdm_service_context,
       std::unique_ptr<media::Renderer> renderer,
-      mojo::InterfaceRequest<mojom::Renderer> request);
+      mojo::PendingReceiver<mojom::Renderer> receiver);
 
   // |mojo_cdm_service_context| can be used to find the CDM to support
   // encrypted media. If null, encrypted media is not supported.