Migrate InterfaceFactory to new Mojo types more

This CL converts old Mojo types to new Mojo types in
InterfaceFactory::CreateCdm and InterfaceFactory::CreateDefaultRenderer.

  - Convert FooRequest to mojo::PendingReceiver.
  - Convert FooPtr to mojo::PendingRemote or mojo::Remote.
  - Convert mojo::StrongBindingSet to mojo::UniqueReceiverSet.

Bug: 955171
Change-Id: I5f26b7efddf75ab48f6b6a5f02d84f91e027ba9a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1883447Reviewed-by: Ken Rockot <rockot@google.com>
Reviewed-by: Chrome Cunningham <chcunningham@chromium.org>
Reviewed-by: Sam McNally <sammc@chromium.org>
Commit-Queue: Gyuyoung Kim <gyuyoung@igalia.com>
Cr-Commit-Position: refs/heads/master@{#710116}

content/browser/media/media_interface_proxy.cc

@@ -166,12 +166,12 @@ void MediaInterfaceProxy::CreateVideoDecoder(
 
 void MediaInterfaceProxy::CreateDefaultRenderer(
     const std::string& audio_device_id,
-    media::mojom::RendererRequest request) {
+    mojo::PendingReceiver<media::mojom::Renderer> receiver) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   InterfaceFactory* factory = media_interface_factory_ptr_->Get();
   if (factory)
-    factory->CreateDefaultRenderer(audio_device_id, std::move(request));
+    factory->CreateDefaultRenderer(audio_device_id, std::move(receiver));
 }
 
 #if BUILDFLAG(ENABLE_CAST_RENDERER)
@@ -230,7 +230,7 @@ void MediaInterfaceProxy::CreateMediaPlayerRenderer(
 
 void MediaInterfaceProxy::CreateCdm(
     const std::string& key_system,
-    media::mojom::ContentDecryptionModuleRequest request) {
+    mojo::PendingReceiver<media::mojom::ContentDecryptionModule> receiver) {
   DCHECK(thread_checker_.CalledOnValidThread());
 #if BUILDFLAG(ENABLE_LIBRARY_CDMS)
   auto* factory = GetCdmFactory(key_system);
@@ -244,7 +244,7 @@ void MediaInterfaceProxy::CreateCdm(
 #endif
 
   if (factory)
-    factory->CreateCdm(key_system, std::move(request));
+    factory->CreateCdm(key_system, std::move(receiver));
 }
 
 void MediaInterfaceProxy::CreateDecryptor(

content/browser/media/media_interface_proxy.h

@@ -55,8 +55,9 @@ class MediaInterfaceProxy : public media::mojom::InterfaceFactory {
       mojo::PendingReceiver<media::mojom::AudioDecoder> receiver) final;
   void CreateVideoDecoder(
       mojo::PendingReceiver<media::mojom::VideoDecoder> receiver) final;
-  void CreateDefaultRenderer(const std::string& audio_device_id,
-                             media::mojom::RendererRequest request) final;
+  void CreateDefaultRenderer(
+      const std::string& audio_device_id,
+      mojo::PendingReceiver<media::mojom::Renderer> receiver) final;
 #if BUILDFLAG(ENABLE_CAST_RENDERER)
   void CreateCastRenderer(
       const base::UnguessableToken& overlay_plane_id,
@@ -76,7 +77,8 @@ class MediaInterfaceProxy : public media::mojom::InterfaceFactory {
           renderer_extension_request) final;
 #endif  // defined(OS_ANDROID)
   void CreateCdm(const std::string& key_system,
-                 media::mojom::ContentDecryptionModuleRequest request) final;
+                 mojo::PendingReceiver<media::mojom::ContentDecryptionModule>
+                     receiver) final;
   void CreateDecryptor(
       int cdm_id,
       mojo::PendingReceiver<media::mojom::Decryptor> receiver) final;

content/browser/media/video_decoder_proxy.cc

@@ -44,7 +44,7 @@ void VideoDecoderProxy::CreateVideoDecoder(
 
 void VideoDecoderProxy::CreateDefaultRenderer(
     const std::string& audio_device_id,
-    media::mojom::RendererRequest request) {}
+    mojo::PendingReceiver<media::mojom::Renderer> receiver) {}
 
 #if BUILDFLAG(ENABLE_CAST_RENDERER)
 void VideoDecoderProxy::CreateCastRenderer(
@@ -69,7 +69,7 @@ void VideoDecoderProxy::CreateMediaPlayerRenderer(
 
 void VideoDecoderProxy::CreateCdm(
     const std::string& key_system,
-    media::mojom::ContentDecryptionModuleRequest request) {}
+    mojo::PendingReceiver<media::mojom::ContentDecryptionModule> receiver) {}
 
 void VideoDecoderProxy::CreateDecryptor(
     int cdm_id,

content/browser/media/video_decoder_proxy.h

@@ -37,8 +37,9 @@ class CONTENT_EXPORT VideoDecoderProxy : public media::mojom::InterfaceFactory {
       mojo::PendingReceiver<media::mojom::AudioDecoder> receiver) final;
   void CreateVideoDecoder(
       mojo::PendingReceiver<media::mojom::VideoDecoder> receiver) final;
-  void CreateDefaultRenderer(const std::string& audio_device_id,
-                             media::mojom::RendererRequest request) final;
+  void CreateDefaultRenderer(
+      const std::string& audio_device_id,
+      mojo::PendingReceiver<media::mojom::Renderer> receiver) final;
 #if BUILDFLAG(ENABLE_CAST_RENDERER)
   void CreateCastRenderer(
       const base::UnguessableToken& overlay_plane_id,
@@ -58,7 +59,8 @@ class CONTENT_EXPORT VideoDecoderProxy : public media::mojom::InterfaceFactory {
       mojo::PendingReceiver<media::mojom::Renderer> receiver) final;
 #endif  // defined(OS_ANDROID)
   void CreateCdm(const std::string& key_system,
-                 media::mojom::ContentDecryptionModuleRequest request) final;
+                 mojo::PendingReceiver<media::mojom::ContentDecryptionModule>
+                     receiver) final;
   void CreateDecryptor(
       int cdm_id,
       mojo::PendingReceiver<media::mojom::Decryptor> receiver) final;

content/renderer/media/media_interface_factory.cc

@@ -54,18 +54,18 @@ void MediaInterfaceFactory::CreateVideoDecoder(
 
 void MediaInterfaceFactory::CreateDefaultRenderer(
     const std::string& audio_device_id,
-    media::mojom::RendererRequest request) {
+    mojo::PendingReceiver<media::mojom::Renderer> receiver) {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&MediaInterfaceFactory::CreateDefaultRenderer,
-                       weak_this_, audio_device_id, std::move(request)));
+                       weak_this_, audio_device_id, std::move(receiver)));
     return;
   }
 
   DVLOG(1) << __func__;
   GetMediaInterfaceFactory()->CreateDefaultRenderer(audio_device_id,
-                                                    std::move(request));
+                                                    std::move(receiver));
 }
 
 #if BUILDFLAG(ENABLE_CAST_RENDERER)
@@ -131,16 +131,16 @@ void MediaInterfaceFactory::CreateFlingingRenderer(
 
 void MediaInterfaceFactory::CreateCdm(
     const std::string& key_system,
-    media::mojom::ContentDecryptionModuleRequest request) {
+    mojo::PendingReceiver<media::mojom::ContentDecryptionModule> receiver) {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE, base::BindOnce(&MediaInterfaceFactory::CreateCdm, weak_this_,
-                                  key_system, std::move(request)));
+                                  key_system, std::move(receiver)));
     return;
   }
 
   DVLOG(1) << __func__ << ": key_system = " << key_system;
-  GetMediaInterfaceFactory()->CreateCdm(key_system, std::move(request));
+  GetMediaInterfaceFactory()->CreateCdm(key_system, std::move(receiver));
 }
 
 void MediaInterfaceFactory::CreateDecryptor(

content/renderer/media/media_interface_factory.h

@@ -39,8 +39,9 @@ class CONTENT_EXPORT MediaInterfaceFactory
       mojo::PendingReceiver<media::mojom::AudioDecoder> receiver) final;
   void CreateVideoDecoder(
       mojo::PendingReceiver<media::mojom::VideoDecoder> receiver) final;
-  void CreateDefaultRenderer(const std::string& audio_device_id,
-                             media::mojom::RendererRequest request) final;
+  void CreateDefaultRenderer(
+      const std::string& audio_device_id,
+      mojo::PendingReceiver<media::mojom::Renderer> receiver) final;
 #if BUILDFLAG(ENABLE_CAST_RENDERER)
   void CreateCastRenderer(
       const base::UnguessableToken& overlay_plane_id,
@@ -60,7 +61,8 @@ class CONTENT_EXPORT MediaInterfaceFactory
           renderer_extension_receiver) final;
 #endif  // defined(OS_ANDROID)
   void CreateCdm(const std::string& key_system,
-                 media::mojom::ContentDecryptionModuleRequest request) final;
+                 mojo::PendingReceiver<media::mojom::ContentDecryptionModule>
+                     receiver) final;
   void CreateDecryptor(
       int cdm_id,
       mojo::PendingReceiver<media::mojom::Decryptor> receiver) final;

media/mojo/mojom/interface_factory.mojom

@@ -21,7 +21,8 @@ interface InterfaceFactory {
   CreateVideoDecoder(pending_receiver<VideoDecoder> video_decoder);
 
   // Creates a regular media::Renderer (DefaultRendererFactory).
-  CreateDefaultRenderer(string audio_device_id, Renderer& renderer);
+  CreateDefaultRenderer(string audio_device_id,
+                        pending_receiver<Renderer> renderer);
 
   [EnableIf=enable_cast_renderer]
   // Creates a CastRenderer (CastRendererFactory).
@@ -62,7 +63,7 @@ interface InterfaceFactory {
   // It should be a reverse domain name, e.g. "com.example.somesystem". However,
   // this call may be initiated by an untrusted process (e.g. renderer), so the
   // implementation must fully validate |key_system| before creating the CDM.
-  CreateCdm(string key_system, ContentDecryptionModule& cdm);
+  CreateCdm(string key_system, pending_receiver<ContentDecryptionModule> cdm);
 
   // Creates a Decryptor associated with the |cdm_id|.
   CreateDecryptor(int32 cdm_id, pending_receiver<Decryptor> decryptor);

media/mojo/services/interface_factory_impl.cc

@@ -95,7 +95,7 @@ void InterfaceFactoryImpl::CreateVideoDecoder(
 
 void InterfaceFactoryImpl::CreateDefaultRenderer(
     const std::string& audio_device_id,
-    mojo::InterfaceRequest<mojom::Renderer> request) {
+    mojo::PendingReceiver<mojom::Renderer> receiver) {
   DVLOG(2) << __func__;
 #if BUILDFLAG(ENABLE_MOJO_RENDERER)
   auto renderer = mojo_media_client_->CreateRenderer(
@@ -112,15 +112,14 @@ void InterfaceFactoryImpl::CreateDefaultRenderer(
 
   MojoRendererService* mojo_renderer_service_ptr = mojo_renderer_service.get();
 
-  mojo::BindingId binding_id = renderer_bindings_.AddBinding(
-      std::move(mojo_renderer_service), std::move(request));
+  mojo::ReceiverId receiver_id = renderer_receivers_.Add(
+      std::move(mojo_renderer_service), std::move(receiver));
 
   // base::Unretained() is safe because the callback will be fired by
-  // |mojo_renderer_service|, which is owned by |renderer_bindings_|.
-  mojo_renderer_service_ptr->set_bad_message_cb(
-      base::Bind(base::IgnoreResult(
-                     &mojo::StrongBindingSet<mojom::Renderer>::RemoveBinding),
-                 base::Unretained(&renderer_bindings_), binding_id));
+  // |mojo_renderer_service|, which is owned by |renderer_receivers_|.
+  mojo_renderer_service_ptr->set_bad_message_cb(base::Bind(
+      base::IgnoreResult(&mojo::UniqueReceiverSet<mojom::Renderer>::Remove),
+      base::Unretained(&renderer_receivers_), receiver_id));
 #endif  // BUILDFLAG(ENABLE_MOJO_RENDERER)
 }
 
@@ -143,15 +142,14 @@ void InterfaceFactoryImpl::CreateCastRenderer(
 
   MojoRendererService* mojo_renderer_service_ptr = mojo_renderer_service.get();
 
-  mojo::BindingId binding_id = renderer_bindings_.AddBinding(
+  mojo::ReceiverId receiver_id = renderer_receivers_.Add(
       std::move(mojo_renderer_service), std::move(receiver));
 
   // base::Unretained() is safe because the callback will be fired by
-  // |mojo_renderer_service|, which is owned by |renderer_bindings_|.
+  // |mojo_renderer_service|, which is owned by |renderer_receivers_|.
   mojo_renderer_service_ptr->set_bad_message_cb(base::BindRepeating(
-      base::IgnoreResult(
-          &mojo::StrongBindingSet<mojom::Renderer>::RemoveBinding),
-      base::Unretained(&renderer_bindings_), binding_id));
+      base::IgnoreResult(&mojo::UniqueReceiverSet<mojom::Renderer>::Remove),
+      base::Unretained(&renderer_receivers_), receiver_id));
 }
 #endif
 
@@ -176,16 +174,16 @@ void InterfaceFactoryImpl::CreateFlingingRenderer(
 
 void InterfaceFactoryImpl::CreateCdm(
     const std::string& /* key_system */,
-    mojo::InterfaceRequest<mojom::ContentDecryptionModule> request) {
+    mojo::PendingReceiver<mojom::ContentDecryptionModule> receiver) {
   DVLOG(2) << __func__;
 #if BUILDFLAG(ENABLE_MOJO_CDM)
   CdmFactory* cdm_factory = GetCdmFactory();
   if (!cdm_factory)
     return;
 
-  cdm_bindings_.AddBinding(
+  cdm_receivers_.Add(
       std::make_unique<MojoCdmService>(cdm_factory, &cdm_service_context_),
-      std::move(request));
+      std::move(receiver));
 #endif  // BUILDFLAG(ENABLE_MOJO_CDM)
 }
 
@@ -241,12 +239,12 @@ bool InterfaceFactoryImpl::IsEmpty() {
 #endif  // BUILDFLAG(ENABLE_MOJO_VIDEO_DECODER)
 
 #if BUILDFLAG(ENABLE_MOJO_RENDERER)
-  if (!renderer_bindings_.empty())
+  if (!renderer_receivers_.empty())
     return false;
 #endif  // BUILDFLAG(ENABLE_MOJO_RENDERER)
 
 #if BUILDFLAG(ENABLE_MOJO_CDM)
-  if (!cdm_bindings_.empty())
+  if (!cdm_receivers_.empty())
     return false;
 #endif  // BUILDFLAG(ENABLE_MOJO_CDM)
 
@@ -277,11 +275,11 @@ void InterfaceFactoryImpl::SetBindingConnectionErrorHandler() {
 #endif  // BUILDFLAG(ENABLE_MOJO_VIDEO_DECODER)
 
 #if BUILDFLAG(ENABLE_MOJO_RENDERER)
-  renderer_bindings_.set_connection_error_handler(connection_error_cb);
+  renderer_receivers_.set_disconnect_handler(connection_error_cb);
 #endif  // BUILDFLAG(ENABLE_MOJO_RENDERER)
 
 #if BUILDFLAG(ENABLE_MOJO_CDM)
-  cdm_bindings_.set_connection_error_handler(connection_error_cb);
+  cdm_receivers_.set_disconnect_handler(connection_error_cb);
 #endif  // BUILDFLAG(ENABLE_MOJO_CDM)
 
 #if BUILDFLAG(ENABLE_LIBRARY_CDMS)

media/mojo/services/interface_factory_impl.h

@@ -23,6 +23,7 @@
 #include "media/mojo/services/mojo_cdm_service_context.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 "mojo/public/cpp/bindings/unique_receiver_set.h"
 #include "services/service_manager/public/cpp/connector.h"
@@ -47,8 +48,9 @@ class InterfaceFactoryImpl : public DeferredDestroy<mojom::InterfaceFactory> {
       mojo::PendingReceiver<mojom::AudioDecoder> receiver) final;
   void CreateVideoDecoder(
       mojo::PendingReceiver<mojom::VideoDecoder> receiver) final;
-  void CreateDefaultRenderer(const std::string& audio_device_id,
-                             mojom::RendererRequest request) final;
+  void CreateDefaultRenderer(
+      const std::string& audio_device_id,
+      mojo::PendingReceiver<mojom::Renderer> receiver) final;
 #if BUILDFLAG(ENABLE_CAST_RENDERER)
   void CreateCastRenderer(
       const base::UnguessableToken& overlay_plane_id,
@@ -67,8 +69,9 @@ class InterfaceFactoryImpl : public DeferredDestroy<mojom::InterfaceFactory> {
           client_extension,
       mojo::PendingReceiver<mojom::Renderer> receiver) final;
 #endif  // defined(OS_ANDROID)
-  void CreateCdm(const std::string& key_system,
-                 mojom::ContentDecryptionModuleRequest request) final;
+  void CreateCdm(
+      const std::string& key_system,
+      mojo::PendingReceiver<mojom::ContentDecryptionModule> receiver) final;
   void CreateDecryptor(int cdm_id,
                        mojo::PendingReceiver<mojom::Decryptor> receiver) final;
   void CreateCdmProxy(const base::Token& cdm_guid,
@@ -105,12 +108,12 @@ class InterfaceFactoryImpl : public DeferredDestroy<mojom::InterfaceFactory> {
 #if BUILDFLAG(ENABLE_MOJO_RENDERER) || BUILDFLAG(ENABLE_CAST_RENDERER)
   // TODO(xhwang): Use MojoMediaLog for Renderer.
   NullMediaLog media_log_;
-  mojo::StrongBindingSet<mojom::Renderer> renderer_bindings_;
+  mojo::UniqueReceiverSet<mojom::Renderer> renderer_receivers_;
 #endif  // BUILDFLAG(ENABLE_MOJO_RENDERER) || BUILDFLAG(ENABLE_CAST_RENDERER)
 
 #if BUILDFLAG(ENABLE_MOJO_CDM)
   std::unique_ptr<CdmFactory> cdm_factory_;
-  mojo::StrongBindingSet<mojom::ContentDecryptionModule> cdm_bindings_;
+  mojo::UniqueReceiverSet<mojom::ContentDecryptionModule> cdm_receivers_;
 #endif  // BUILDFLAG(ENABLE_MOJO_CDM)
 
 #if BUILDFLAG(ENABLE_LIBRARY_CDMS)

media/mojo/services/media_service_unittest.cc

@@ -31,7 +31,6 @@
 #include "media/mojo/services/media_interface_provider.h"
 #include "media/mojo/services/media_manifest.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "services/service_manager/public/cpp/manifest_builder.h"
@@ -162,8 +161,9 @@ class MediaServiceTest : public testing::Test {
     auto provider = std::make_unique<MediaInterfaceProvider>(
         host_interfaces.InitWithNewPipeAndPassReceiver());
 
-    connector()->BindInterface(mojom::kMediaServiceName, &media_service_);
-    media_service_.set_connection_error_handler(
+    connector()->Connect(mojom::kMediaServiceName,
+                         media_service_.BindNewPipeAndPassReceiver());
+    media_service_.set_disconnect_handler(
         base::BindRepeating(&MediaServiceTest::MediaServiceConnectionClosed,
                             base::Unretained(this)));
     media_service_->CreateInterfaceFactory(
@@ -180,8 +180,9 @@ class MediaServiceTest : public testing::Test {
   // Returns the CDM ID associated with the CDM.
   int InitializeCdm(const std::string& key_system, bool expected_result) {
     base::RunLoop run_loop;
-    interface_factory_->CreateCdm(key_system, mojo::MakeRequest(&cdm_));
-    cdm_.set_connection_error_handler(base::BindRepeating(
+    interface_factory_->CreateCdm(key_system,
+                                  cdm_.BindNewPipeAndPassReceiver());
+    cdm_.set_disconnect_handler(base::BindRepeating(
         &MediaServiceTest::OnCdmConnectionError, base::Unretained(this)));
 
     int cdm_id = CdmContext::kInvalidCdmId;
@@ -253,8 +254,8 @@ class MediaServiceTest : public testing::Test {
   void InitializeRenderer(const VideoDecoderConfig& video_config,
                           bool expected_result) {
     base::RunLoop run_loop;
-    interface_factory_->CreateDefaultRenderer(std::string(),
-                                              mojo::MakeRequest(&renderer_));
+    interface_factory_->CreateDefaultRenderer(
+        std::string(), renderer_.BindNewPipeAndPassReceiver());
 
     video_stream_.set_video_decoder_config(video_config);
 
@@ -284,11 +285,11 @@ class MediaServiceTest : public testing::Test {
   service_manager::TestServiceManager test_service_manager_;
   service_manager::TestService test_service_;
 
-  mojom::MediaServicePtr media_service_;
+  mojo::Remote<mojom::MediaService> media_service_;
   mojo::Remote<mojom::InterfaceFactory> interface_factory_;
-  mojom::ContentDecryptionModulePtr cdm_;
+  mojo::Remote<mojom::ContentDecryptionModule> cdm_;
   mojo::Remote<mojom::CdmProxy> cdm_proxy_;
-  mojom::RendererPtr renderer_;
+  mojo::Remote<mojom::Renderer> renderer_;
 
   NiceMock<MockCdmProxyClient> cdm_proxy_client_;
   mojo::AssociatedBinding<mojom::CdmProxyClient> cdm_proxy_client_binding_;