Migrate references of content::mojom::RendererAudioOutputStreamFactory

Convert both the implementation and clients in the browser and renderer
processes for the content.mojom.RendererAudioOutputStreamFactory
interface, and adapt unit tests.

Bug: 955171
Change-Id: I1732245f699c7c05e1d771d1210fed60076322fb
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1801151Reviewed-by: Oksana Zhuravlova <oksamyt@chromium.org>
Reviewed-by: Tommi <tommi@chromium.org>
Reviewed-by: Arthur Sonzogni <arthursonzogni@chromium.org>
Commit-Queue: Mario Sanchez Prada <mario@igalia.com>
Cr-Commit-Position: refs/heads/master@{#697130}

content/browser/frame_host/render_frame_host_impl.cc

@@ -6244,21 +6244,21 @@ void RenderFrameHostImpl::CreateAudioInputStreamFactory(
 }
 
 void RenderFrameHostImpl::CreateAudioOutputStreamFactory(
-    mojom::RendererAudioOutputStreamFactoryRequest request) {
+    mojo::PendingReceiver<mojom::RendererAudioOutputStreamFactory> receiver) {
   if (base::FeatureList::IsEnabled(features::kAudioServiceAudioStreams)) {
     media::AudioSystem* audio_system =
         BrowserMainLoop::GetInstance()->audio_system();
     MediaStreamManager* media_stream_manager =
         BrowserMainLoop::GetInstance()->media_stream_manager();
     audio_service_audio_output_stream_factory_.emplace(
-        this, audio_system, media_stream_manager, std::move(request));
+        this, audio_system, media_stream_manager, std::move(receiver));
   } else {
     RendererAudioOutputStreamFactoryContext* factory_context =
         GetProcess()->GetRendererAudioOutputStreamFactoryContext();
     DCHECK(factory_context);
     in_content_audio_output_stream_factory_ =
         RenderFrameAudioOutputStreamFactoryHandle::CreateFactory(
-            factory_context, GetRoutingID(), std::move(request));
+            factory_context, GetRoutingID(), std::move(receiver));
   }
 }
 

content/browser/frame_host/render_frame_host_impl.h

@@ -1523,7 +1523,7 @@ class CONTENT_EXPORT RenderFrameHostImpl
   void CreateAudioInputStreamFactory(
       mojo::PendingReceiver<mojom::RendererAudioInputStreamFactory> receiver);
   void CreateAudioOutputStreamFactory(
-      mojom::RendererAudioOutputStreamFactoryRequest request);
+      mojo::PendingReceiver<mojom::RendererAudioOutputStreamFactory> receiver);
 
   void BindMediaInterfaceFactoryRequest(
       media::mojom::InterfaceFactoryRequest request);

content/browser/renderer_host/media/old_render_frame_audio_output_stream_factory.cc

@@ -28,7 +28,7 @@ std::unique_ptr<RenderFrameAudioOutputStreamFactoryHandle,
 RenderFrameAudioOutputStreamFactoryHandle::CreateFactory(
     RendererAudioOutputStreamFactoryContext* context,
     int render_frame_id,
-    mojom::RendererAudioOutputStreamFactoryRequest request) {
+    mojo::PendingReceiver<mojom::RendererAudioOutputStreamFactory> receiver) {
   std::unique_ptr<RenderFrameAudioOutputStreamFactoryHandle,
                   BrowserThread::DeleteOnIOThread>
       handle(new RenderFrameAudioOutputStreamFactoryHandle(context,
@@ -38,7 +38,7 @@ RenderFrameAudioOutputStreamFactoryHandle::CreateFactory(
   base::PostTask(
       FROM_HERE, {BrowserThread::IO},
       base::BindOnce(&RenderFrameAudioOutputStreamFactoryHandle::Init,
-                     base::Unretained(handle.get()), std::move(request)));
+                     base::Unretained(handle.get()), std::move(receiver)));
   return handle;
 }
 
@@ -51,12 +51,12 @@ RenderFrameAudioOutputStreamFactoryHandle::
     RenderFrameAudioOutputStreamFactoryHandle(
         RendererAudioOutputStreamFactoryContext* context,
         int render_frame_id)
-    : impl_(render_frame_id, context), binding_(&impl_) {}
+    : impl_(render_frame_id, context), receiver_(&impl_) {}
 
 void RenderFrameAudioOutputStreamFactoryHandle::Init(
-    mojom::RendererAudioOutputStreamFactoryRequest request) {
+    mojo::PendingReceiver<mojom::RendererAudioOutputStreamFactory> receiver) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  binding_.Bind(std::move(request));
+  receiver_.Bind(std::move(receiver));
 }
 
 OldRenderFrameAudioOutputStreamFactory::OldRenderFrameAudioOutputStreamFactory(

content/browser/renderer_host/media/old_render_frame_audio_output_stream_factory.h

@@ -14,13 +14,14 @@
 #include "content/common/content_export.h"
 #include "content/common/media/renderer_audio_output_stream_factory.mojom.h"
 #include "content/public/browser/browser_thread.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 
 namespace content {
 
 class RendererAudioOutputStreamFactoryContext;
 
-// Handles a RendererAudioOutputStreamFactory request for a render frame host,
+// Handles a RendererAudioOutputStreamFactory receiver for a render frame host,
 // using the provided RendererAudioOutputStreamFactoryContext. This class may
 // be constructed on any thread, but must be used on the IO thread after that.
 // This class is used for creating streams hosted by the browser. It is being
@@ -77,14 +78,15 @@ class CONTENT_EXPORT OldRenderFrameAudioOutputStreamFactory
   DISALLOW_COPY_AND_ASSIGN(OldRenderFrameAudioOutputStreamFactory);
 };
 
-// This class is a convenient bundle of factory and binding.
+// This class is a convenient bundle of factory and receiver.
 class CONTENT_EXPORT RenderFrameAudioOutputStreamFactoryHandle {
  public:
   static std::unique_ptr<RenderFrameAudioOutputStreamFactoryHandle,
                          BrowserThread::DeleteOnIOThread>
-  CreateFactory(RendererAudioOutputStreamFactoryContext* context,
-                int render_frame_id,
-                mojom::RendererAudioOutputStreamFactoryRequest request);
+  CreateFactory(
+      RendererAudioOutputStreamFactoryContext* context,
+      int render_frame_id,
+      mojo::PendingReceiver<mojom::RendererAudioOutputStreamFactory> receiver);
 
   ~RenderFrameAudioOutputStreamFactoryHandle();
 
@@ -93,10 +95,11 @@ class CONTENT_EXPORT RenderFrameAudioOutputStreamFactoryHandle {
       RendererAudioOutputStreamFactoryContext* context,
       int render_frame_id);
 
-  void Init(mojom::RendererAudioOutputStreamFactoryRequest request);
+  void Init(
+      mojo::PendingReceiver<mojom::RendererAudioOutputStreamFactory> receiver);
 
   OldRenderFrameAudioOutputStreamFactory impl_;
-  mojo::Binding<mojom::RendererAudioOutputStreamFactory> binding_;
+  mojo::Receiver<mojom::RendererAudioOutputStreamFactory> receiver_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameAudioOutputStreamFactoryHandle);
 };

content/browser/renderer_host/media/old_render_frame_audio_output_stream_factory_unittest.cc

@@ -20,6 +20,7 @@
 #include "media/base/audio_parameters.h"
 #include "media/mojo/mojom/audio_data_pipe.mojom.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -29,11 +30,6 @@ namespace content {
 namespace {
 
 using testing::Test;
-using AudioOutputStreamFactory = mojom::RendererAudioOutputStreamFactory;
-using AudioOutputStreamFactoryPtr =
-    mojo::InterfacePtr<AudioOutputStreamFactory>;
-using AudioOutputStreamFactoryRequest =
-    mojo::InterfaceRequest<AudioOutputStreamFactory>;
 using AudioOutputStream = media::mojom::AudioOutputStream;
 using AudioOutputStreamPtr = mojo::InterfacePtr<AudioOutputStream>;
 using AudioOutputStreamRequest = mojo::InterfaceRequest<AudioOutputStream>;
@@ -143,23 +139,23 @@ class MockContext : public RendererAudioOutputStreamFactoryContext {
     return std::move(delegate_);
   }
 
-  AudioOutputStreamFactoryPtr CreateFactory() {
+  mojo::Remote<mojom::RendererAudioOutputStreamFactory> CreateFactory() {
     DCHECK(!factory_);
-    AudioOutputStreamFactoryPtr ret;
+    mojo::Remote<mojom::RendererAudioOutputStreamFactory> remote;
     factory_ = std::make_unique<OldRenderFrameAudioOutputStreamFactory>(
         kRenderFrameId, this);
-    factory_binding_ = std::make_unique<
-        mojo::Binding<mojom::RendererAudioOutputStreamFactory>>(
-        factory_.get(), mojo::MakeRequest(&ret));
-    return ret;
+    factory_receiver_ = std::make_unique<
+        mojo::Receiver<mojom::RendererAudioOutputStreamFactory>>(
+        factory_.get(), remote.BindNewPipeAndPassReceiver());
+    return remote;
   }
 
  private:
   const std::string salt_;
   const bool auth_ok_;
   std::unique_ptr<OldRenderFrameAudioOutputStreamFactory> factory_;
-  std::unique_ptr<mojo::Binding<mojom::RendererAudioOutputStreamFactory>>
-      factory_binding_;
+  std::unique_ptr<mojo::Receiver<mojom::RendererAudioOutputStreamFactory>>
+      factory_receiver_;
   std::unique_ptr<media::AudioOutputDelegate> delegate_;
   media::AudioOutputDelegate::EventHandler** delegate_event_handler_location_ =
       nullptr;
@@ -221,12 +217,13 @@ TEST(OldRenderFrameAudioOutputStreamFactoryTest, CreateStream) {
   auto factory_context = std::make_unique<MockContext>(true);
   factory_context->PrepareDelegateForCreation(
       std::make_unique<MockAudioOutputDelegate>(), &event_handler);
-  AudioOutputStreamFactoryPtr factory_ptr = factory_context->CreateFactory();
+  mojo::Remote<mojom::RendererAudioOutputStreamFactory> factory_remote =
+      factory_context->CreateFactory();
 
   media::OutputDeviceStatus status;
   media::AudioParameters params;
   std::string id;
-  factory_ptr->RequestDeviceAuthorization(
+  factory_remote->RequestDeviceAuthorization(
       mojo::MakeRequest(&provider), base::nullopt, "default",
       base::BindOnce(&AuthCallback, base::Unretained(&status),
                      base::Unretained(&params), base::Unretained(&id)));
@@ -264,12 +261,13 @@ TEST(OldRenderFrameAudioOutputStreamFactoryTest, NotAuthorized_Denied) {
   content::BrowserTaskEnvironment task_environment;
   AudioOutputStreamProviderPtr output_provider;
   auto factory_context = std::make_unique<MockContext>(false);
-  AudioOutputStreamFactoryPtr factory_ptr = factory_context->CreateFactory();
+  mojo::Remote<mojom::RendererAudioOutputStreamFactory> factory_remote =
+      factory_context->CreateFactory();
 
   media::OutputDeviceStatus status;
   media::AudioParameters params;
   std::string id;
-  factory_ptr->RequestDeviceAuthorization(
+  factory_remote->RequestDeviceAuthorization(
       mojo::MakeRequest(&output_provider), base::nullopt, "default",
       base::BindOnce(&AuthCallback, base::Unretained(&status),
                      base::Unretained(&params), base::Unretained(&id)));
@@ -291,9 +289,10 @@ TEST(OldRenderFrameAudioOutputStreamFactoryTest,
           base::BindOnce([](bool* destructed) { *destructed = true; },
                          &delegate_is_destructed)),
       &event_handler);
-  AudioOutputStreamFactoryPtr factory_ptr = factory_context->CreateFactory();
+  mojo::Remote<mojom::RendererAudioOutputStreamFactory> factory_remote =
+      factory_context->CreateFactory();
 
-  factory_ptr->RequestDeviceAuthorization(
+  factory_remote->RequestDeviceAuthorization(
       mojo::MakeRequest(&provider), base::nullopt, "default",
       base::BindOnce([](media::OutputDeviceStatus status,
                         const media::AudioParameters& params,
@@ -322,9 +321,10 @@ TEST(OldRenderFrameAudioOutputStreamFactoryTest, DelegateError_DeletesStream) {
           base::BindOnce([](bool* destructed) { *destructed = true; },
                          &delegate_is_destructed)),
       &event_handler);
-  AudioOutputStreamFactoryPtr factory_ptr = factory_context->CreateFactory();
+  mojo::Remote<mojom::RendererAudioOutputStreamFactory> factory_remote =
+      factory_context->CreateFactory();
 
-  factory_ptr->RequestDeviceAuthorization(
+  factory_remote->RequestDeviceAuthorization(
       mojo::MakeRequest(&provider), base::nullopt, "default",
       base::BindOnce([](media::OutputDeviceStatus status,
                         const media::AudioParameters& params,

content/browser/renderer_host/media/render_frame_audio_output_stream_factory.cc

@@ -29,6 +29,7 @@
 #include "media/base/output_device_info.h"
 #include "media/mojo/mojom/audio_output_stream.mojom.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 
 namespace content {
 
@@ -38,11 +39,12 @@ class RenderFrameAudioOutputStreamFactory::Core final
   Core(RenderFrameHost* frame,
        media::AudioSystem* audio_system,
        MediaStreamManager* media_stream_manager,
-       mojom::RendererAudioOutputStreamFactoryRequest request);
+       mojo::PendingReceiver<mojom::RendererAudioOutputStreamFactory> receiver);
 
   ~Core() final = default;
 
-  void Init(mojom::RendererAudioOutputStreamFactoryRequest request);
+  void Init(
+      mojo::PendingReceiver<mojom::RendererAudioOutputStreamFactory> receiver);
 
   size_t current_number_of_providers_for_testing() {
     return stream_providers_.size();
@@ -130,7 +132,7 @@ class RenderFrameAudioOutputStreamFactory::Core final
   const int frame_id_;
   AudioOutputAuthorizationHandler authorization_handler_;
 
-  mojo::Binding<mojom::RendererAudioOutputStreamFactory> binding_;
+  mojo::Receiver<mojom::RendererAudioOutputStreamFactory> receiver_{this};
   // Always null-check this weak pointer before dereferencing it.
   base::WeakPtr<ForwardingAudioStreamFactory::Core> forwarding_factory_;
 
@@ -150,11 +152,11 @@ RenderFrameAudioOutputStreamFactory::RenderFrameAudioOutputStreamFactory(
     RenderFrameHost* frame,
     media::AudioSystem* audio_system,
     MediaStreamManager* media_stream_manager,
-    mojom::RendererAudioOutputStreamFactoryRequest request)
+    mojo::PendingReceiver<mojom::RendererAudioOutputStreamFactory> receiver)
     : core_(new Core(frame,
                      audio_system,
                      media_stream_manager,
-                     std::move(request))) {
+                     std::move(receiver))) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
@@ -179,11 +181,10 @@ RenderFrameAudioOutputStreamFactory::Core::Core(
     RenderFrameHost* frame,
     media::AudioSystem* audio_system,
     MediaStreamManager* media_stream_manager,
-    mojom::RendererAudioOutputStreamFactoryRequest request)
+    mojo::PendingReceiver<mojom::RendererAudioOutputStreamFactory> receiver)
     : process_id_(frame->GetProcess()->GetID()),
       frame_id_(frame->GetRoutingID()),
-      authorization_handler_(audio_system, media_stream_manager, process_id_),
-      binding_(this) {
+      authorization_handler_(audio_system, media_stream_manager, process_id_) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ForwardingAudioStreamFactory::Core* tmp_factory =
@@ -202,14 +203,14 @@ RenderFrameAudioOutputStreamFactory::Core::Core(
   // thread.
   base::PostTask(
       FROM_HERE, {BrowserThread::IO},
-      base::BindOnce(&Core::Init, base::Unretained(this), std::move(request)));
+      base::BindOnce(&Core::Init, base::Unretained(this), std::move(receiver)));
 }
 
 void RenderFrameAudioOutputStreamFactory::Core::Init(
-    mojom::RendererAudioOutputStreamFactoryRequest request) {
+    mojo::PendingReceiver<mojom::RendererAudioOutputStreamFactory> receiver) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  binding_.Bind(std::move(request));
+  receiver_.Bind(std::move(receiver));
 }
 
 void RenderFrameAudioOutputStreamFactory::Core::RequestDeviceAuthorization(

content/browser/renderer_host/media/render_frame_audio_output_stream_factory.h

@@ -11,6 +11,7 @@
 #include "base/macros.h"
 #include "content/common/content_export.h"
 #include "content/common/media/renderer_audio_output_stream_factory.mojom.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 
 namespace media {
 class AudioSystem;
@@ -45,7 +46,7 @@ class CONTENT_EXPORT RenderFrameAudioOutputStreamFactory final {
       RenderFrameHost* frame,
       media::AudioSystem* audio_system,
       MediaStreamManager* media_stream_manager,
-      mojom::RendererAudioOutputStreamFactoryRequest request);
+      mojo::PendingReceiver<mojom::RendererAudioOutputStreamFactory> receiver);
 
   ~RenderFrameAudioOutputStreamFactory();
 

content/browser/renderer_host/media/render_frame_audio_output_stream_factory_unittest.cc

@@ -30,8 +30,11 @@
 #include "media/audio/test_audio_thread.h"
 #include "media/base/audio_parameters.h"
 #include "media/mojo/mojom/audio_output_stream.mojom.h"
-#include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/pending_associated_remote.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/audio/public/cpp/fake_stream_factory.h"
 #include "services/audio/public/mojom/constants.mojom.h"
 #include "services/audio/public/mojom/stream_factory.mojom.h"
@@ -133,24 +136,24 @@ class RenderFrameAudioOutputStreamFactoryTest
 };
 
 TEST_F(RenderFrameAudioOutputStreamFactoryTest, ConstructDestruct) {
-  mojom::RendererAudioOutputStreamFactoryPtr factory_ptr;
-  RenderFrameAudioOutputStreamFactory factory(main_rfh(), audio_system_.get(),
-                                              media_stream_manager_.get(),
-                                              mojo::MakeRequest(&factory_ptr));
+  mojo::Remote<mojom::RendererAudioOutputStreamFactory> factory_remote;
+  RenderFrameAudioOutputStreamFactory factory(
+      main_rfh(), audio_system_.get(), media_stream_manager_.get(),
+      factory_remote.BindNewPipeAndPassReceiver());
 }
 
 TEST_F(RenderFrameAudioOutputStreamFactoryTest,
        RequestDeviceAuthorizationForDefaultDevice_StatusOk) {
-  mojom::RendererAudioOutputStreamFactoryPtr factory_ptr;
-  RenderFrameAudioOutputStreamFactory factory(main_rfh(), audio_system_.get(),
-                                              media_stream_manager_.get(),
-                                              mojo::MakeRequest(&factory_ptr));
+  mojo::Remote<mojom::RendererAudioOutputStreamFactory> factory_remote;
+  RenderFrameAudioOutputStreamFactory factory(
+      main_rfh(), audio_system_.get(), media_stream_manager_.get(),
+      factory_remote.BindNewPipeAndPassReceiver());
 
   media::mojom::AudioOutputStreamProviderPtr provider_ptr;
   MockAuthorizationCallback mock_callback;
-  factory_ptr->RequestDeviceAuthorization(mojo::MakeRequest(&provider_ptr),
-                                          base::nullopt, kDefaultDeviceId,
-                                          mock_callback.Get());
+  factory_remote->RequestDeviceAuthorization(mojo::MakeRequest(&provider_ptr),
+                                             base::nullopt, kDefaultDeviceId,
+                                             mock_callback.Get());
 
   EXPECT_CALL(mock_callback,
               Run(media::OUTPUT_DEVICE_STATUS_OK, _, std::string()));
@@ -163,16 +166,16 @@ TEST_F(RenderFrameAudioOutputStreamFactoryTest,
 TEST_F(
     RenderFrameAudioOutputStreamFactoryTest,
     RequestDeviceAuthorizationForDefaultDeviceAndDestroyProviderPtr_CleansUp) {
-  mojom::RendererAudioOutputStreamFactoryPtr factory_ptr;
-  RenderFrameAudioOutputStreamFactory factory(main_rfh(), audio_system_.get(),
-                                              media_stream_manager_.get(),
-                                              mojo::MakeRequest(&factory_ptr));
+  mojo::Remote<mojom::RendererAudioOutputStreamFactory> factory_remote;
+  RenderFrameAudioOutputStreamFactory factory(
+      main_rfh(), audio_system_.get(), media_stream_manager_.get(),
+      factory_remote.BindNewPipeAndPassReceiver());
 
   media::mojom::AudioOutputStreamProviderPtr provider_ptr;
   MockAuthorizationCallback mock_callback;
-  factory_ptr->RequestDeviceAuthorization(mojo::MakeRequest(&provider_ptr),
-                                          base::nullopt, kDefaultDeviceId,
-                                          mock_callback.Get());
+  factory_remote->RequestDeviceAuthorization(mojo::MakeRequest(&provider_ptr),
+                                             base::nullopt, kDefaultDeviceId,
+                                             mock_callback.Get());
   provider_ptr.reset();
 
   EXPECT_CALL(mock_callback,
@@ -186,16 +189,16 @@ TEST_F(
 TEST_F(
     RenderFrameAudioOutputStreamFactoryTest,
     RequestDeviceAuthorizationForNondefaultDeviceWithoutAuthorization_Fails) {
-  mojom::RendererAudioOutputStreamFactoryPtr factory_ptr;
-  RenderFrameAudioOutputStreamFactory factory(main_rfh(), audio_system_.get(),
-                                              media_stream_manager_.get(),
-                                              mojo::MakeRequest(&factory_ptr));
+  mojo::Remote<mojom::RendererAudioOutputStreamFactory> factory_remote;
+  RenderFrameAudioOutputStreamFactory factory(
+      main_rfh(), audio_system_.get(), media_stream_manager_.get(),
+      factory_remote.BindNewPipeAndPassReceiver());
 
   media::mojom::AudioOutputStreamProviderPtr provider_ptr;
   MockAuthorizationCallback mock_callback;
-  factory_ptr->RequestDeviceAuthorization(mojo::MakeRequest(&provider_ptr),
-                                          base::nullopt, kDeviceId,
-                                          mock_callback.Get());
+  factory_remote->RequestDeviceAuthorization(mojo::MakeRequest(&provider_ptr),
+                                             base::nullopt, kDeviceId,
+                                             mock_callback.Get());
 
   EXPECT_CALL(mock_callback,
               Run(Ne(media::OUTPUT_DEVICE_STATUS_OK), _, std::string()));
@@ -207,16 +210,16 @@ TEST_F(
 
 TEST_F(RenderFrameAudioOutputStreamFactoryTest,
        CreateStream_CreatesStreamAndFreesProvider) {
-  mojom::RendererAudioOutputStreamFactoryPtr factory_ptr;
-  RenderFrameAudioOutputStreamFactory factory(main_rfh(), audio_system_.get(),
-                                              media_stream_manager_.get(),
-                                              mojo::MakeRequest(&factory_ptr));
+  mojo::Remote<mojom::RendererAudioOutputStreamFactory> factory_remote;
+  RenderFrameAudioOutputStreamFactory factory(
+      main_rfh(), audio_system_.get(), media_stream_manager_.get(),
+      factory_remote.BindNewPipeAndPassReceiver());
 
   media::mojom::AudioOutputStreamProviderPtr provider_ptr;
   MockAuthorizationCallback mock_callback;
-  factory_ptr->RequestDeviceAuthorization(mojo::MakeRequest(&provider_ptr),
-                                          base::nullopt, kDefaultDeviceId,
-                                          mock_callback.Get());
+  factory_remote->RequestDeviceAuthorization(mojo::MakeRequest(&provider_ptr),
+                                             base::nullopt, kDefaultDeviceId,
+                                             mock_callback.Get());
   {
     media::mojom::AudioOutputStreamProviderClientPtr client;
     mojo::MakeRequest(&client);
@@ -239,14 +242,14 @@ TEST_F(RenderFrameAudioOutputStreamFactoryTest,
   MockAuthorizationCallback mock_callback;
 
   {
-    mojom::RendererAudioOutputStreamFactoryPtr factory_ptr;
+    mojo::Remote<mojom::RendererAudioOutputStreamFactory> factory_remote;
     RenderFrameAudioOutputStreamFactory factory(
         main_rfh(), audio_system_.get(), media_stream_manager_.get(),
-        mojo::MakeRequest(&factory_ptr));
+        factory_remote.BindNewPipeAndPassReceiver());
 
-    factory_ptr->RequestDeviceAuthorization(mojo::MakeRequest(&provider_ptr),
-                                            base::nullopt, kDefaultDeviceId,
-                                            mock_callback.Get());
+    factory_remote->RequestDeviceAuthorization(mojo::MakeRequest(&provider_ptr),
+                                               base::nullopt, kDefaultDeviceId,
+                                               mock_callback.Get());
 
     audio::mojom::StreamFactory::CreateOutputStreamCallback created_callback;
     EXPECT_CALL(mock_callback,

content/renderer/media/audio/audio_output_ipc_factory.cc

@@ -25,7 +25,7 @@ AudioOutputIPCFactory::AudioOutputIPCFactory(
 
 AudioOutputIPCFactory::~AudioOutputIPCFactory() {
   // Allow destruction in tests.
-  DCHECK(factory_ptrs_.empty());
+  DCHECK(factory_remotes_.empty());
   DCHECK_EQ(instance_, this);
   instance_ = nullptr;
 }
@@ -42,16 +42,16 @@ AudioOutputIPCFactory::CreateAudioOutputIPC(int frame_id) const {
 void AudioOutputIPCFactory::RegisterRemoteFactory(
     int frame_id,
     service_manager::InterfaceProvider* interface_provider) {
-  mojom::RendererAudioOutputStreamFactoryPtr factory_ptr;
-  interface_provider->GetInterface(&factory_ptr);
-  // PassInterface unbinds the message pipe from the current thread. This
-  // allows us to bind it to the IO thread.
+  mojo::PendingRemote<mojom::RendererAudioOutputStreamFactory> factory_remote;
+  interface_provider->GetInterface(
+      factory_remote.InitWithNewPipeAndPassReceiver());
   // Unretained is safe due to the contract at the top of the header file.
+  // It's safe to pass the |factory_remote| PendingRemote between threads.
   io_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&AudioOutputIPCFactory::RegisterRemoteFactoryOnIOThread,
                      base::Unretained(this), frame_id,
-                     factory_ptr.PassInterface()));
+                     std::move(factory_remote)));
 }
 
 void AudioOutputIPCFactory::MaybeDeregisterRemoteFactory(int frame_id) {
@@ -65,17 +65,17 @@ void AudioOutputIPCFactory::MaybeDeregisterRemoteFactory(int frame_id) {
 mojom::RendererAudioOutputStreamFactory*
 AudioOutputIPCFactory::GetRemoteFactory(int frame_id) const {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
-  auto it = factory_ptrs_.find(frame_id);
-  return it == factory_ptrs_.end() ? nullptr : it->second.get();
+  auto it = factory_remotes_.find(frame_id);
+  return it == factory_remotes_.end() ? nullptr : it->second.get();
 }
 
 void AudioOutputIPCFactory::RegisterRemoteFactoryOnIOThread(
     int frame_id,
-    mojom::RendererAudioOutputStreamFactoryPtrInfo factory_ptr_info) {
+    mojo::PendingRemote<mojom::RendererAudioOutputStreamFactory>
+        factory_pending_remote) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   std::pair<StreamFactoryMap::iterator, bool> emplace_result =
-      factory_ptrs_.emplace(frame_id,
-                            mojo::MakeProxy(std::move(factory_ptr_info)));
+      factory_remotes_.emplace(frame_id, std::move(factory_pending_remote));
 
   DCHECK(emplace_result.second) << "Attempt to register a factory for a "
                                    "frame which already has a factory "
@@ -85,9 +85,9 @@ void AudioOutputIPCFactory::RegisterRemoteFactoryOnIOThread(
   DCHECK(emplaced_factory.is_bound())
       << "Factory is not bound to a remote implementation.";
 
-  // Unretained is safe because |this| owns the binding, so a connection error
+  // Unretained is safe because |this| owns the remote, so a connection error
   // cannot trigger after destruction.
-  emplaced_factory.set_connection_error_handler(base::BindOnce(
+  emplaced_factory.set_disconnect_handler(base::BindOnce(
       &AudioOutputIPCFactory::MaybeDeregisterRemoteFactoryOnIOThread,
       base::Unretained(this), frame_id));
 }
@@ -96,10 +96,10 @@ void AudioOutputIPCFactory::MaybeDeregisterRemoteFactoryOnIOThread(
     int frame_id) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   // This function can be called both by the frame and the connection error
-  // handler of the factory pointer. Calling erase multiple times even though
+  // handler of the factory remote. Calling erase multiple times even though
   // there is nothing to erase is safe, so we don't have to handle this in any
   // particular way.
-  factory_ptrs_.erase(frame_id);
+  factory_remotes_.erase(frame_id);
 }
 
 }  // namespace content

content/renderer/media/audio/audio_output_ipc_factory.h

@@ -11,6 +11,8 @@
 #include "base/memory/ref_counted.h"
 #include "content/common/content_export.h"
 #include "content/common/media/renderer_audio_output_stream_factory.mojom.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace base {
 class SingleThreadTaskRunner;
@@ -63,13 +65,15 @@ class CONTENT_EXPORT AudioOutputIPCFactory {
 
  private:
   using StreamFactoryMap =
-      base::flat_map<int, mojom::RendererAudioOutputStreamFactoryPtr>;
+      base::flat_map<int,
+                     mojo::Remote<mojom::RendererAudioOutputStreamFactory>>;
 
   mojom::RendererAudioOutputStreamFactory* GetRemoteFactory(int frame_id) const;
 
   void RegisterRemoteFactoryOnIOThread(
       int frame_id,
-      mojom::RendererAudioOutputStreamFactoryPtrInfo factory_ptr_info);
+      mojo::PendingRemote<mojom::RendererAudioOutputStreamFactory>
+          factory_pending_remote);
 
   void MaybeDeregisterRemoteFactoryOnIOThread(int frame_id);
 
@@ -77,7 +81,7 @@ class CONTENT_EXPORT AudioOutputIPCFactory {
   bool UsingMojoFactories() const;
 
   // Maps frame id to the corresponding factory.
-  StreamFactoryMap factory_ptrs_;
+  StreamFactoryMap factory_remotes_;
 
   const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 

content/renderer/media/audio/audio_output_ipc_factory_unittest.cc

@@ -14,8 +14,8 @@
 #include "base/test/task_environment.h"
 #include "base/threading/thread.h"
 #include "media/audio/audio_output_ipc.h"
-#include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -38,7 +38,7 @@ std::unique_ptr<base::Thread> MakeIOThread() {
 
 class FakeRemoteFactory : public mojom::RendererAudioOutputStreamFactory {
  public:
-  FakeRemoteFactory() : binding_(this) {}
+  FakeRemoteFactory() = default;
   ~FakeRemoteFactory() override {}
 
   void RequestDeviceAuthorization(
@@ -58,14 +58,14 @@ class FakeRemoteFactory : public mojom::RendererAudioOutputStreamFactory {
   }
 
   void Bind(mojo::ScopedMessagePipeHandle handle) {
-    EXPECT_FALSE(binding_.is_bound());
-    binding_.Bind(
+    EXPECT_FALSE(receiver_.is_bound());
+    receiver_.Bind(
         mojo::InterfaceRequest<mojom::RendererAudioOutputStreamFactory>(
             std::move(handle)));
   }
 
  private:
-  mojo::Binding<mojom::RendererAudioOutputStreamFactory> binding_;
+  mojo::Receiver<mojom::RendererAudioOutputStreamFactory> receiver_{this};
   base::OnceClosure on_called_;
 };
 

content/renderer/media/audio/mojo_audio_output_ipc_unittest.cc

@@ -17,6 +17,8 @@
 #include "media/audio/audio_device_description.h"
 #include "media/base/audio_parameters.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/receiver.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -93,7 +95,7 @@ class TestRemoteFactory : public mojom::RendererAudioOutputStreamFactory {
  public:
   TestRemoteFactory()
       : expect_request_(false),
-        binding_(this, mojo::MakeRequest(&this_proxy_)) {}
+        receiver_(this, this_remote_.BindNewPipeAndPassReceiver()) {}
 
   ~TestRemoteFactory() override {}
 
@@ -146,9 +148,9 @@ class TestRemoteFactory : public mojom::RendererAudioOutputStreamFactory {
   }
 
   void Disconnect() {
-    binding_.Close();
-    this_proxy_.reset();
-    binding_.Bind(mojo::MakeRequest(&this_proxy_));
+    receiver_.reset();
+    this_remote_.reset();
+    receiver_.Bind(this_remote_.BindNewPipeAndPassReceiver());
     provider_binding_.reset();
     provider_.reset();
     expect_request_ = false;
@@ -159,14 +161,14 @@ class TestRemoteFactory : public mojom::RendererAudioOutputStreamFactory {
   }
 
  private:
-  mojom::RendererAudioOutputStreamFactory* get() { return this_proxy_.get(); }
+  mojom::RendererAudioOutputStreamFactory* get() { return this_remote_.get(); }
 
   bool expect_request_;
   base::Optional<base::UnguessableToken> expected_session_id_;
   std::string expected_device_id_;
 
-  mojom::RendererAudioOutputStreamFactoryPtr this_proxy_;
-  mojo::Binding<mojom::RendererAudioOutputStreamFactory> binding_;
+  mojo::Remote<mojom::RendererAudioOutputStreamFactory> this_remote_;
+  mojo::Receiver<mojom::RendererAudioOutputStreamFactory> receiver_{this};
   std::unique_ptr<TestStreamProvider> provider_;
   base::Optional<mojo::Binding<media::mojom::AudioOutputStreamProvider>>
       provider_binding_;

content/test/renderer_audio_output_stream_factory_context_impl_unittest.cc

@@ -31,7 +31,9 @@
 #include "media/audio/simple_sources.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/media_switches.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/remote.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -189,12 +191,12 @@ class RendererAudioOutputStreamFactoryIntegrationTest : public Test {
   }
 
   UniqueAudioOutputStreamFactoryPtr CreateAndBindFactory(
-      mojom::RendererAudioOutputStreamFactoryRequest request) {
+      mojo::PendingReceiver<mojom::RendererAudioOutputStreamFactory> receiver) {
     factory_context_.reset(new RendererAudioOutputStreamFactoryContextImpl(
         kRenderProcessId, &audio_system_, &audio_manager_,
         media_stream_manager_.get()));
     return RenderFrameAudioOutputStreamFactoryHandle::CreateFactory(
-        factory_context_.get(), kRenderFrameId, std::move(request));
+        factory_context_.get(), kRenderFrameId, std::move(receiver));
   }
 
   std::unique_ptr<MediaStreamManager> media_stream_manager_;
@@ -229,35 +231,39 @@ TEST_F(RendererAudioOutputStreamFactoryIntegrationTest, StreamIntegrationTest) {
       },
       &create_stream_called, stream));
 
-  mojom::RendererAudioOutputStreamFactoryPtr stream_factory;
-  auto factory_handle =
-      CreateAndBindFactory(mojo::MakeRequest(&stream_factory));
+  mojo::PendingRemote<mojom::RendererAudioOutputStreamFactory>
+      pending_stream_factory;
+  auto factory_handle = CreateAndBindFactory(
+      pending_stream_factory.InitWithNewPipeAndPassReceiver());
 
   base::Thread renderer_side_ipc_thread("Renderer IPC thread");
   ASSERT_TRUE(renderer_side_ipc_thread.Start());
   auto renderer_ipc_task_runner = renderer_side_ipc_thread.task_runner();
 
-  // Bind |stream_factory| to |renderer_ipc_task_runner|.
-  mojom::RendererAudioOutputStreamFactory* factory_ptr;
+  // Bind |pending_stream_factory| to |renderer_ipc_task_runner|.
+  mojo::Remote<mojom::RendererAudioOutputStreamFactory> stream_factory;
+  mojom::RendererAudioOutputStreamFactory* factory_remote;
   renderer_ipc_task_runner->PostTask(
-      FROM_HERE, base::BindOnce(
-                     [](mojom::RendererAudioOutputStreamFactoryPtr* factory,
-                        mojom::RendererAudioOutputStreamFactoryPtrInfo info,
-                        mojom::RendererAudioOutputStreamFactory** ptr) {
-                       factory->Bind(std::move(info));
-                       *ptr = factory->get();
-                     },
-                     base::Unretained(&stream_factory),
-                     stream_factory.PassInterface(), &factory_ptr));
-  // Wait for factory_ptr to be set.
+      FROM_HERE,
+      base::BindOnce(
+          [](mojo::Remote<mojom::RendererAudioOutputStreamFactory>* factory,
+             mojo::PendingRemote<mojom::RendererAudioOutputStreamFactory>
+                 pending_remote,
+             mojom::RendererAudioOutputStreamFactory** ptr) {
+            factory->Bind(std::move(pending_remote));
+            *ptr = factory->get();
+          },
+          base::Unretained(&stream_factory), std::move(pending_stream_factory),
+          &factory_remote));
+  // Wait for factory_remote to be set.
   SyncWith(renderer_ipc_task_runner);
 
   auto renderer_side_ipc = std::make_unique<MojoAudioOutputIPC>(
       base::BindRepeating(
-          [](mojom::RendererAudioOutputStreamFactory* factory_ptr) {
-            return factory_ptr;
+          [](mojom::RendererAudioOutputStreamFactory* factory_remote) {
+            return factory_remote;
           },
-          factory_ptr),
+          factory_remote),
       renderer_ipc_task_runner);
 
   auto device = base::MakeRefCounted<media::AudioOutputDevice>(
@@ -278,7 +284,8 @@ TEST_F(RendererAudioOutputStreamFactoryIntegrationTest, StreamIntegrationTest) {
   // |stream_factory| must be destroyed on the correct thread.
   renderer_ipc_task_runner->PostTask(
       FROM_HERE,
-      base::BindOnce([](mojom::RendererAudioOutputStreamFactoryPtr) {},
+      base::BindOnce([](mojo::Remote<mojom::RendererAudioOutputStreamFactory>
+                            stream_factory) { stream_factory.reset(); },
                      std::move(stream_factory)));
   SyncWith(renderer_ipc_task_runner);
   // Wait for any clean-up tasks.