Convert AudioDecoder to new Mojo types

This CL converts AudioDecoder{Ptr, Request} in media and content
to the new Mojo type, and uses pending_receiver<AudioDecoder> in
interface_factory.mojom.

Bug: 955171
Change-Id: I6a5cdc5a6c7c41be286baa8cd7235cb6adf33e41
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1864787Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Reviewed-by: Sam McNally <sammc@chromium.org>
Reviewed-by: Ken Rockot <rockot@google.com>
Commit-Queue: Miyoung Shin <myid.shin@igalia.com>
Cr-Commit-Position: refs/heads/master@{#706807}

content/browser/media/media_interface_proxy.cc

@@ -149,11 +149,11 @@ MediaInterfaceProxy::~MediaInterfaceProxy() {
 }
 
 void MediaInterfaceProxy::CreateAudioDecoder(
-    media::mojom::AudioDecoderRequest request) {
+    mojo::PendingReceiver<media::mojom::AudioDecoder> receiver) {
   DCHECK(thread_checker_.CalledOnValidThread());
   InterfaceFactory* factory = media_interface_factory_ptr_->Get();
   if (factory)
-    factory->CreateAudioDecoder(std::move(request));
+    factory->CreateAudioDecoder(std::move(receiver));
 }
 
 void MediaInterfaceProxy::CreateVideoDecoder(

content/browser/media/media_interface_proxy.h

@@ -49,7 +49,8 @@ class MediaInterfaceProxy : public media::mojom::InterfaceFactory {
   ~MediaInterfaceProxy() final;
 
   // media::mojom::InterfaceFactory implementation.
-  void CreateAudioDecoder(media::mojom::AudioDecoderRequest request) final;
+  void CreateAudioDecoder(
+      mojo::PendingReceiver<media::mojom::AudioDecoder> receiver) final;
   void CreateVideoDecoder(media::mojom::VideoDecoderRequest request) final;
   void CreateDefaultRenderer(const std::string& audio_device_id,
                              media::mojom::RendererRequest request) final;

content/browser/media/video_decoder_proxy.cc

@@ -31,7 +31,7 @@ void VideoDecoderProxy::Add(media::mojom::InterfaceFactoryRequest request) {
 }
 
 void VideoDecoderProxy::CreateAudioDecoder(
-    media::mojom::AudioDecoderRequest request) {}
+    mojo::PendingReceiver<media::mojom::AudioDecoder> receiver) {}
 
 void VideoDecoderProxy::CreateVideoDecoder(
     media::mojom::VideoDecoderRequest request) {

content/browser/media/video_decoder_proxy.h

@@ -30,7 +30,8 @@ class VideoDecoderProxy : public media::mojom::InterfaceFactory {
   void Add(media::mojom::InterfaceFactoryRequest request);
 
   // media::mojom::InterfaceFactory implementation.
-  void CreateAudioDecoder(media::mojom::AudioDecoderRequest request) final;
+  void CreateAudioDecoder(
+      mojo::PendingReceiver<media::mojom::AudioDecoder> receiver) final;
   void CreateVideoDecoder(media::mojom::VideoDecoderRequest request) final;
   void CreateDefaultRenderer(const std::string& audio_device_id,
                              media::mojom::RendererRequest request) final;

content/renderer/media/media_interface_factory.cc

@@ -27,16 +27,16 @@ MediaInterfaceFactory::~MediaInterfaceFactory() {
 }
 
 void MediaInterfaceFactory::CreateAudioDecoder(
-    media::mojom::AudioDecoderRequest request) {
+    mojo::PendingReceiver<media::mojom::AudioDecoder> receiver) {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE, base::BindOnce(&MediaInterfaceFactory::CreateAudioDecoder,
-                                  weak_this_, std::move(request)));
+                                  weak_this_, std::move(receiver)));
     return;
   }
 
   DVLOG(1) << __func__;
-  GetMediaInterfaceFactory()->CreateAudioDecoder(std::move(request));
+  GetMediaInterfaceFactory()->CreateAudioDecoder(std::move(receiver));
 }
 
 void MediaInterfaceFactory::CreateVideoDecoder(

content/renderer/media/media_interface_factory.h

@@ -34,7 +34,8 @@ class CONTENT_EXPORT MediaInterfaceFactory
   ~MediaInterfaceFactory() final;
 
   // media::mojom::InterfaceFactory implementation.
-  void CreateAudioDecoder(media::mojom::AudioDecoderRequest request) final;
+  void CreateAudioDecoder(
+      mojo::PendingReceiver<media::mojom::AudioDecoder> receiver) final;
   void CreateVideoDecoder(media::mojom::VideoDecoderRequest request) final;
   void CreateDefaultRenderer(const std::string& audio_device_id,
                              media::mojom::RendererRequest request) final;

media/mojo/clients/mojo_audio_decoder.cc

@@ -21,9 +21,9 @@ namespace media {
 
 MojoAudioDecoder::MojoAudioDecoder(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-    mojom::AudioDecoderPtr remote_decoder)
+    mojo::PendingRemote<mojom::AudioDecoder> remote_decoder)
     : task_runner_(task_runner),
-      remote_decoder_info_(remote_decoder.PassInterface()),
+      pending_remote_decoder_(std::move(remote_decoder)),
       writer_capacity_(
           GetDefaultDecoderBufferConverterCapacity(DemuxerStream::AUDIO)),
       client_binding_(this) {
@@ -54,7 +54,7 @@ void MojoAudioDecoder::Initialize(const AudioDecoderConfig& config,
     BindRemoteDecoder();
 
   // This could happen during reinitialization.
-  if (remote_decoder_.encountered_error()) {
+  if (!remote_decoder_.is_connected()) {
     DVLOG(1) << __func__ << ": Connection error happened.";
     task_runner_->PostTask(FROM_HERE,
                            base::BindOnce(std::move(init_cb), false));
@@ -89,7 +89,7 @@ void MojoAudioDecoder::Decode(scoped_refptr<DecoderBuffer> media_buffer,
   DVLOG(3) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  if (remote_decoder_.encountered_error()) {
+  if (!remote_decoder_.is_connected()) {
     task_runner_->PostTask(
         FROM_HERE, base::BindOnce(decode_cb, DecodeStatus::DECODE_ERROR));
     return;
@@ -115,7 +115,7 @@ void MojoAudioDecoder::Reset(base::OnceClosure closure) {
   DVLOG(2) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  if (remote_decoder_.encountered_error()) {
+  if (!remote_decoder_.is_connected()) {
     if (decode_cb_) {
       task_runner_->PostTask(
           FROM_HERE,
@@ -143,11 +143,11 @@ void MojoAudioDecoder::BindRemoteDecoder() {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  remote_decoder_.Bind(std::move(remote_decoder_info_));
+  remote_decoder_.Bind(std::move(pending_remote_decoder_));
 
   // Using base::Unretained(this) is safe because |this| owns |remote_decoder_|,
   // and the error handler can't be invoked once |remote_decoder_| is destroyed.
-  remote_decoder_.set_connection_error_handler(
+  remote_decoder_.set_disconnect_handler(
       base::Bind(&MojoAudioDecoder::OnConnectionError, base::Unretained(this)));
 
   mojom::AudioDecoderClientAssociatedPtrInfo client_ptr_info;
@@ -173,7 +173,7 @@ void MojoAudioDecoder::OnWaiting(WaitingReason reason) {
 void MojoAudioDecoder::OnConnectionError() {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(remote_decoder_.encountered_error());
+  DCHECK(!remote_decoder_.is_connected());
 
   if (init_cb_) {
     std::move(init_cb_).Run(false);

media/mojo/clients/mojo_audio_decoder.h

@@ -14,6 +14,8 @@
 #include "media/mojo/mojom/media_types.mojom.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace base {
 class SingleThreadTaskRunner;
@@ -27,7 +29,7 @@ class MojoDecoderBufferWriter;
 class MojoAudioDecoder : public AudioDecoder, public mojom::AudioDecoderClient {
  public:
   MojoAudioDecoder(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-                   mojom::AudioDecoderPtr remote_decoder);
+                   mojo::PendingRemote<mojom::AudioDecoder> remote_decoder);
   ~MojoAudioDecoder() final;
 
   // AudioDecoder implementation.
@@ -69,12 +71,12 @@ class MojoAudioDecoder : public AudioDecoder, public mojom::AudioDecoderClient {
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   // This class is constructed on one thread and used exclusively on another
-  // thread. This member is used to safely pass the AudioDecoderPtr from one
-  // thread to another. It is set in the constructor and is consumed in
-  // Initialize().
-  mojom::AudioDecoderPtrInfo remote_decoder_info_;
+  // thread. This member is used to safely pass the
+  // mojo::PendingRemote<AudioDecoder> from one thread to another. It is set in
+  // the constructor and is consumed in Initialize().
+  mojo::PendingRemote<mojom::AudioDecoder> pending_remote_decoder_;
 
-  mojom::AudioDecoderPtr remote_decoder_;
+  mojo::Remote<mojom::AudioDecoder> remote_decoder_;
 
   std::unique_ptr<MojoDecoderBufferWriter> mojo_decoder_buffer_writer_;
 

media/mojo/clients/mojo_audio_decoder_unittest.cc

@@ -23,7 +23,9 @@
 #include "media/mojo/mojom/audio_decoder.mojom.h"
 #include "media/mojo/services/mojo_audio_decoder_service.h"
 #include "media/mojo/services/mojo_cdm_service_context.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -59,12 +61,12 @@ class MojoAudioDecoderTest : public ::testing::Test {
     service_task_runner_ = service_thread_.task_runner();
 
     // Setup the mojo connection.
-    mojom::AudioDecoderPtr remote_audio_decoder;
+    mojo::PendingRemote<mojom::AudioDecoder> remote_audio_decoder;
     service_task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&MojoAudioDecoderTest::ConnectToService,
                        base::Unretained(this),
-                       base::Passed(mojo::MakeRequest(&remote_audio_decoder))));
+                       remote_audio_decoder.InitWithNewPipeAndPassReceiver()));
     mojo_audio_decoder_.reset(
         new MojoAudioDecoder(task_environment_.GetMainThreadTaskRunner(),
                              std::move(remote_audio_decoder)));
@@ -106,7 +108,7 @@ class MojoAudioDecoderTest : public ::testing::Test {
     run_loop_->QuitWhenIdle();
   }
 
-  void ConnectToService(mojom::AudioDecoderRequest request) {
+  void ConnectToService(mojo::PendingReceiver<mojom::AudioDecoder> receiver) {
     DCHECK(service_task_runner_->BelongsToCurrentThread());
 
     std::unique_ptr<StrictMock<MockAudioDecoder>> mock_audio_decoder(
@@ -123,10 +125,10 @@ class MojoAudioDecoderTest : public ::testing::Test {
     EXPECT_CALL(*mock_audio_decoder_, Reset_(_))
         .WillRepeatedly(RunOnceCallback<0>());
 
-    mojo::MakeStrongBinding(
+    mojo::MakeSelfOwnedReceiver(
         std::make_unique<MojoAudioDecoderService>(
             &mojo_cdm_service_context_, std::move(mock_audio_decoder)),
-        std::move(request));
+        std::move(receiver));
   }
 
   void SetWriterCapacity(uint32_t capacity) {

media/mojo/clients/mojo_decoder_factory.cc

@@ -15,7 +15,7 @@
 #include "media/mojo/clients/mojo_video_decoder.h"
 #include "media/mojo/mojom/audio_decoder.mojom.h"
 #include "media/mojo/mojom/interface_factory.mojom.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 
 namespace media {
 
@@ -32,11 +32,12 @@ void MojoDecoderFactory::CreateAudioDecoders(
     MediaLog* media_log,
     std::vector<std::unique_ptr<AudioDecoder>>* audio_decoders) {
 #if BUILDFLAG(ENABLE_MOJO_AUDIO_DECODER)
-  mojom::AudioDecoderPtr audio_decoder_ptr;
-  interface_factory_->CreateAudioDecoder(mojo::MakeRequest(&audio_decoder_ptr));
+  mojo::PendingRemote<mojom::AudioDecoder> audio_decoder;
+  interface_factory_->CreateAudioDecoder(
+      audio_decoder.InitWithNewPipeAndPassReceiver());
 
   audio_decoders->push_back(std::make_unique<MojoAudioDecoder>(
-      task_runner, std::move(audio_decoder_ptr)));
+      task_runner, std::move(audio_decoder)));
 #endif
 }
 

media/mojo/mojom/interface_factory.mojom

@@ -17,7 +17,7 @@ import "mojo/public/mojom/base/unguessable_token.mojom";
 // A factory for creating media mojo interfaces. Renderers can only access
 // ContentDecryptionModules created with the same factory.
 interface InterfaceFactory {
-  CreateAudioDecoder(AudioDecoder& audio_decoder);
+  CreateAudioDecoder(pending_receiver<AudioDecoder> audio_decoder);
   CreateVideoDecoder(VideoDecoder& video_decoder);
 
   // Creates a regular media::Renderer (DefaultRendererFactory).

media/mojo/services/interface_factory_impl.cc

@@ -62,7 +62,7 @@ InterfaceFactoryImpl::~InterfaceFactoryImpl() {
 // mojom::InterfaceFactory implementation.
 
 void InterfaceFactoryImpl::CreateAudioDecoder(
-    mojo::InterfaceRequest<mojom::AudioDecoder> request) {
+    mojo::PendingReceiver<mojom::AudioDecoder> receiver) {
   DVLOG(2) << __func__;
 #if BUILDFLAG(ENABLE_MOJO_AUDIO_DECODER)
   scoped_refptr<base::SingleThreadTaskRunner> task_runner(
@@ -75,10 +75,10 @@ void InterfaceFactoryImpl::CreateAudioDecoder(
     return;
   }
 
-  audio_decoder_bindings_.AddBinding(
+  audio_decoder_receivers_.Add(
       std::make_unique<MojoAudioDecoderService>(&cdm_service_context_,
                                                 std::move(audio_decoder)),
-      std::move(request));
+      std::move(receiver));
 #endif  // BUILDFLAG(ENABLE_MOJO_AUDIO_DECODER)
 }
 
@@ -228,7 +228,7 @@ void InterfaceFactoryImpl::OnDestroyPending(base::OnceClosure destroy_cb) {
 
 bool InterfaceFactoryImpl::IsEmpty() {
 #if BUILDFLAG(ENABLE_MOJO_AUDIO_DECODER)
-  if (!audio_decoder_bindings_.empty())
+  if (!audio_decoder_receivers_.empty())
     return false;
 #endif  // BUILDFLAG(ENABLE_MOJO_AUDIO_DECODER)
 
@@ -266,7 +266,7 @@ void InterfaceFactoryImpl::SetBindingConnectionErrorHandler() {
       &InterfaceFactoryImpl::OnBindingConnectionError, base::Unretained(this));
 
 #if BUILDFLAG(ENABLE_MOJO_AUDIO_DECODER)
-  audio_decoder_bindings_.set_connection_error_handler(connection_error_cb);
+  audio_decoder_receivers_.set_disconnect_handler(connection_error_cb);
 #endif  // BUILDFLAG(ENABLE_MOJO_AUDIO_DECODER)
 
 #if BUILDFLAG(ENABLE_MOJO_VIDEO_DECODER)

media/mojo/services/interface_factory_impl.h

@@ -40,7 +40,8 @@ class InterfaceFactoryImpl : public DeferredDestroy<mojom::InterfaceFactory> {
   ~InterfaceFactoryImpl() final;
 
   // mojom::InterfaceFactory implementation.
-  void CreateAudioDecoder(mojom::AudioDecoderRequest request) final;
+  void CreateAudioDecoder(
+      mojo::PendingReceiver<mojom::AudioDecoder> receiver) final;
   void CreateVideoDecoder(mojom::VideoDecoderRequest request) final;
   void CreateDefaultRenderer(const std::string& audio_device_id,
                              mojom::RendererRequest request) final;
@@ -87,7 +88,7 @@ class InterfaceFactoryImpl : public DeferredDestroy<mojom::InterfaceFactory> {
   MojoCdmServiceContext cdm_service_context_;
 
 #if BUILDFLAG(ENABLE_MOJO_AUDIO_DECODER)
-  mojo::StrongBindingSet<mojom::AudioDecoder> audio_decoder_bindings_;
+  mojo::UniqueReceiverSet<mojom::AudioDecoder> audio_decoder_receivers_;
 #endif  // BUILDFLAG(ENABLE_MOJO_AUDIO_DECODER)
 
 #if BUILDFLAG(ENABLE_MOJO_VIDEO_DECODER)