Migrate references of media::mojom::AudioOutputStreamObserver to new Mojo types

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

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

content/browser/renderer_host/media/audio_output_delegate_impl.cc

@@ -103,7 +103,8 @@ std::unique_ptr<media::AudioOutputDelegate> AudioOutputDelegateImpl::Create(
     int render_frame_id,
     int render_process_id,
     const media::AudioParameters& params,
-    media::mojom::AudioOutputStreamObserverPtr observer,
+    mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+        pending_observer,
     const std::string& output_device_id) {
   auto socket = std::make_unique<base::CancelableSyncSocket>();
   auto reader = media::AudioSyncReader::Create(
@@ -115,7 +116,7 @@ std::unique_ptr<media::AudioOutputDelegate> AudioOutputDelegateImpl::Create(
   return std::make_unique<AudioOutputDelegateImpl>(
       std::move(reader), std::move(socket), handler, audio_manager,
       std::move(audio_log), media_observer, stream_id, render_frame_id,
-      render_process_id, params, std::move(observer), output_device_id);
+      render_process_id, params, std::move(pending_observer), output_device_id);
 }
 
 AudioOutputDelegateImpl::AudioOutputDelegateImpl(
@@ -129,14 +130,15 @@ AudioOutputDelegateImpl::AudioOutputDelegateImpl(
     int render_frame_id,
     int render_process_id,
     const media::AudioParameters& params,
-    media::mojom::AudioOutputStreamObserverPtr observer,
+    mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+        pending_observer,
     const std::string& output_device_id)
     : subscriber_(handler),
       audio_log_(std::move(audio_log)),
       reader_(std::move(reader)),
       foreign_socket_(std::move(foreign_socket)),
       stream_id_(stream_id),
-      observer_(std::move(observer)) {
+      observer_(std::move(pending_observer)) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(subscriber_);
   DCHECK(audio_manager);

content/browser/renderer_host/media/audio_output_delegate_impl.h

@@ -15,6 +15,8 @@
 #include "media/audio/audio_output_delegate.h"
 #include "media/mojo/mojom/audio_logging.mojom.h"
 #include "media/mojo/mojom/audio_output_stream.mojom.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace content {
 class MediaObserver;
@@ -43,7 +45,8 @@ class CONTENT_EXPORT AudioOutputDelegateImpl
       int render_frame_id,
       int render_process_id,
       const media::AudioParameters& params,
-      media::mojom::AudioOutputStreamObserverPtr observer,
+      mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+          pending_observer,
       const std::string& output_device_id);
 
   AudioOutputDelegateImpl(
@@ -57,7 +60,8 @@ class CONTENT_EXPORT AudioOutputDelegateImpl
       int render_frame_id,
       int render_process_id,
       const media::AudioParameters& params,
-      media::mojom::AudioOutputStreamObserverPtr observer,
+      mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+          pending_observer,
       const std::string& output_device_id);
 
   ~AudioOutputDelegateImpl() override;
@@ -100,7 +104,7 @@ class CONTENT_EXPORT AudioOutputDelegateImpl
   base::RepeatingTimer poll_timer_;
   bool is_audible_ = false;
   // |observer_| is notified about changes in the audible state of the stream.
-  media::mojom::AudioOutputStreamObserverPtr observer_;
+  mojo::Remote<media::mojom::AudioOutputStreamObserver> observer_;
 
   base::WeakPtrFactory<AudioOutputDelegateImpl> weak_factory_{this};
 

content/browser/renderer_host/media/audio_output_delegate_impl_unittest.cc

@@ -28,6 +28,8 @@
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/media_switches.h"
 #include "media/mojo/mojom/audio_output_stream.mojom.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/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -167,19 +169,20 @@ class AudioOutputDelegateTest : public testing::Test {
 
   ~AudioOutputDelegateTest() override { audio_manager_->Shutdown(); }
 
-  mojo::StrongBindingPtr<media::mojom::AudioOutputStreamObserver>
-  CreateObserverBinding(
-      media::mojom::AudioOutputStreamObserverPtr* observer_ptr) {
-    return mojo::MakeStrongBinding(
+  mojo::SelfOwnedReceiverRef<media::mojom::AudioOutputStreamObserver>
+  CreateObserverReceiver(
+      mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>*
+          observer_remote) {
+    return mojo::MakeSelfOwnedReceiver(
         std::make_unique<MockAudioOutputStreamObserver>(),
-        mojo::MakeRequest(observer_ptr));
+        observer_remote->InitWithNewPipeAndPassReceiver());
   }
 
   MockAudioOutputStreamObserver& GetMockObserver(
       mojo::StrongBindingPtr<media::mojom::AudioOutputStreamObserver>*
-          observer_binding) {
+          observer_receiver) {
     return *static_cast<MockAudioOutputStreamObserver*>(
-        (*observer_binding)->impl());
+        (*observer_receiver)->impl());
   }
 
   // Test bodies are here, so that we can run them on the IO thread.
@@ -189,10 +192,12 @@ class AudioOutputDelegateTest : public testing::Test {
     EXPECT_CALL(event_handler_, GotOnStreamCreated());
     EXPECT_CALL(mirroring_manager_,
                 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull()));
-    media::mojom::AudioOutputStreamObserverPtr observer_ptr;
-    auto observer_binding = CreateObserverBinding(&observer_ptr);
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStartPlaying()).Times(0);
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStopPlaying()).Times(0);
+    mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+        observer_remote;
+    auto observer_receiver = CreateObserverReceiver(&observer_remote);
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStartPlaying())
+        .Times(0);
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStopPlaying()).Times(0);
 
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
@@ -202,7 +207,7 @@ class AudioOutputDelegateTest : public testing::Test {
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), CreateDummyMojoAudioLog(), &media_observer_,
           kStreamId, kRenderFrameId, kRenderProcessId, Params(),
-          std::move(observer_ptr), kDefaultDeviceId);
+          std::move(observer_remote), kDefaultDeviceId);
 
       SyncWithAllThreads();
 
@@ -218,12 +223,13 @@ class AudioOutputDelegateTest : public testing::Test {
     EXPECT_CALL(event_handler_, GotOnStreamCreated());
     EXPECT_CALL(mirroring_manager_,
                 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull()));
-    media::mojom::AudioOutputStreamObserverPtr observer_ptr;
-    auto observer_binding = CreateObserverBinding(&observer_ptr);
+    mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+        observer_remote;
+    auto observer_receiver = CreateObserverReceiver(&observer_remote);
     if (use_bound_observer) {
-      EXPECT_CALL(GetMockObserver(&observer_binding), DidStartPlaying())
+      EXPECT_CALL(GetMockObserver(&observer_receiver), DidStartPlaying())
           .Times(0);
-      EXPECT_CALL(GetMockObserver(&observer_binding), DidStopPlaying())
+      EXPECT_CALL(GetMockObserver(&observer_receiver), DidStopPlaying())
           .Times(0);
     }
 
@@ -231,22 +237,23 @@ class AudioOutputDelegateTest : public testing::Test {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
       auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
                                                    Params(), socket.get());
-      media::mojom::AudioOutputStreamObserverPtr observer_ptr;
-      auto observer_binding = CreateObserverBinding(&observer_ptr);
+      mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+          observer_remote;
+      auto observer_receiver = CreateObserverReceiver(&observer_remote);
       if (use_bound_observer) {
         InSequence s;
-        EXPECT_CALL(GetMockObserver(&observer_binding), DidStartPlaying());
-        EXPECT_CALL(GetMockObserver(&observer_binding), DidStopPlaying());
+        EXPECT_CALL(GetMockObserver(&observer_receiver), DidStartPlaying());
+        EXPECT_CALL(GetMockObserver(&observer_receiver), DidStopPlaying());
       }
 
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), CreateDummyMojoAudioLog(), &media_observer_,
           kStreamId, kRenderFrameId, kRenderProcessId, Params(),
-          std::move(observer_ptr), kDefaultDeviceId);
+          std::move(observer_remote), kDefaultDeviceId);
 
       if (!use_bound_observer)
-        observer_binding->Close();
+        observer_receiver->Close();
 
       delegate.OnPlayStream();
 
@@ -264,10 +271,12 @@ class AudioOutputDelegateTest : public testing::Test {
     EXPECT_CALL(event_handler_, GotOnStreamCreated());
     EXPECT_CALL(mirroring_manager_,
                 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull()));
-    media::mojom::AudioOutputStreamObserverPtr observer_ptr;
-    auto observer_binding = CreateObserverBinding(&observer_ptr);
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStartPlaying()).Times(0);
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStopPlaying()).Times(0);
+    mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+        observer_remote;
+    auto observer_receiver = CreateObserverReceiver(&observer_remote);
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStartPlaying())
+        .Times(0);
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStopPlaying()).Times(0);
 
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
@@ -277,7 +286,7 @@ class AudioOutputDelegateTest : public testing::Test {
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), CreateDummyMojoAudioLog(), &media_observer_,
           kStreamId, kRenderFrameId, kRenderProcessId, Params(),
-          std::move(observer_ptr), kDefaultDeviceId);
+          std::move(observer_remote), kDefaultDeviceId);
 
       delegate.OnPauseStream();
 
@@ -300,19 +309,20 @@ class AudioOutputDelegateTest : public testing::Test {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
       auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
                                                    Params(), socket.get());
-      media::mojom::AudioOutputStreamObserverPtr observer_ptr;
-      auto observer_binding = CreateObserverBinding(&observer_ptr);
+      mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+          observer_remote;
+      auto observer_receiver = CreateObserverReceiver(&observer_remote);
       InSequence s;
-      EXPECT_CALL(GetMockObserver(&observer_binding), DidStartPlaying());
-      EXPECT_CALL(GetMockObserver(&observer_binding), DidStopPlaying());
-      EXPECT_CALL(GetMockObserver(&observer_binding), DidStartPlaying());
-      EXPECT_CALL(GetMockObserver(&observer_binding), DidStopPlaying());
+      EXPECT_CALL(GetMockObserver(&observer_receiver), DidStartPlaying());
+      EXPECT_CALL(GetMockObserver(&observer_receiver), DidStopPlaying());
+      EXPECT_CALL(GetMockObserver(&observer_receiver), DidStartPlaying());
+      EXPECT_CALL(GetMockObserver(&observer_receiver), DidStopPlaying());
 
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), CreateDummyMojoAudioLog(), &media_observer_,
           kStreamId, kRenderFrameId, kRenderProcessId, Params(),
-          std::move(observer_ptr), kDefaultDeviceId);
+          std::move(observer_remote), kDefaultDeviceId);
 
       delegate.OnPlayStream();
       delegate.OnPauseStream();
@@ -337,17 +347,18 @@ class AudioOutputDelegateTest : public testing::Test {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
       auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
                                                    Params(), socket.get());
-      media::mojom::AudioOutputStreamObserverPtr observer_ptr;
-      auto observer_binding = CreateObserverBinding(&observer_ptr);
+      mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+          observer_remote;
+      auto observer_receiver = CreateObserverReceiver(&observer_remote);
       InSequence s;
-      EXPECT_CALL(GetMockObserver(&observer_binding), DidStartPlaying());
-      EXPECT_CALL(GetMockObserver(&observer_binding), DidStopPlaying());
+      EXPECT_CALL(GetMockObserver(&observer_receiver), DidStartPlaying());
+      EXPECT_CALL(GetMockObserver(&observer_receiver), DidStopPlaying());
 
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), CreateDummyMojoAudioLog(), &media_observer_,
           kStreamId, kRenderFrameId, kRenderProcessId, Params(),
-          std::move(observer_ptr), kDefaultDeviceId);
+          std::move(observer_remote), kDefaultDeviceId);
 
       delegate.OnPlayStream();
       delegate.OnPlayStream();
@@ -366,10 +377,12 @@ class AudioOutputDelegateTest : public testing::Test {
     EXPECT_CALL(event_handler_, GotOnStreamCreated());
     EXPECT_CALL(mirroring_manager_,
                 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull()));
-    media::mojom::AudioOutputStreamObserverPtr observer_ptr;
-    auto observer_binding = CreateObserverBinding(&observer_ptr);
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStartPlaying()).Times(0);
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStopPlaying()).Times(0);
+    mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+        observer_remote;
+    auto observer_receiver = CreateObserverReceiver(&observer_remote);
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStartPlaying())
+        .Times(0);
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStopPlaying()).Times(0);
 
     DummyAudioOutputStream stream;
     {
@@ -380,7 +393,7 @@ class AudioOutputDelegateTest : public testing::Test {
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), CreateDummyMojoAudioLog(), &media_observer_,
           kStreamId, kRenderFrameId, kRenderProcessId, Params(),
-          std::move(observer_ptr), kDefaultDeviceId);
+          std::move(observer_remote), kDefaultDeviceId);
 
       delegate.GetControllerForTesting()->StartDiverting(&stream);
 
@@ -407,8 +420,8 @@ class AudioOutputDelegateTest : public testing::Test {
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), CreateDummyMojoAudioLog(), &media_observer_,
-          kStreamId, kRenderFrameId, kRenderProcessId, Params(), nullptr,
-          kDefaultDeviceId);
+          kStreamId, kRenderFrameId, kRenderProcessId, Params(),
+          mojo::NullRemote(), kDefaultDeviceId);
 
       delegate.GetControllerForTesting()->StartDiverting(&stream);
 
@@ -429,11 +442,12 @@ class AudioOutputDelegateTest : public testing::Test {
     EXPECT_CALL(event_handler_, GotOnStreamCreated());
     EXPECT_CALL(mirroring_manager_,
                 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull()));
-    media::mojom::AudioOutputStreamObserverPtr observer_ptr;
-    auto observer_binding = CreateObserverBinding(&observer_ptr);
+    mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+        observer_remote;
+    auto observer_receiver = CreateObserverReceiver(&observer_remote);
     InSequence s;
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStartPlaying());
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStopPlaying());
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStartPlaying());
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStopPlaying());
 
     DummyAudioOutputStream stream;
     {
@@ -444,7 +458,7 @@ class AudioOutputDelegateTest : public testing::Test {
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), CreateDummyMojoAudioLog(), &media_observer_,
           kStreamId, kRenderFrameId, kRenderProcessId, Params(),
-          std::move(observer_ptr), kDefaultDeviceId);
+          std::move(observer_remote), kDefaultDeviceId);
 
       delegate.OnPlayStream();
       delegate.GetControllerForTesting()->StartDiverting(&stream);
@@ -472,10 +486,11 @@ class AudioOutputDelegateTest : public testing::Test {
     EXPECT_CALL(mirroring_manager_,
                 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull()));
     EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull()));
-    media::mojom::AudioOutputStreamObserverPtr observer_ptr;
-    auto observer_binding = CreateObserverBinding(&observer_ptr);
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStartPlaying());
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStopPlaying());
+    mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+        observer_remote;
+    auto observer_receiver = CreateObserverReceiver(&observer_remote);
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStartPlaying());
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStopPlaying());
 
     auto socket = std::make_unique<base::CancelableSyncSocket>();
     auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
@@ -484,7 +499,7 @@ class AudioOutputDelegateTest : public testing::Test {
         std::move(reader), std::move(socket), &event_handler_,
         audio_manager_.get(), CreateDummyMojoAudioLog(), &media_observer_,
         kStreamId, kRenderFrameId, kRenderProcessId, Params(),
-        std::move(observer_ptr), kDefaultDeviceId);
+        std::move(observer_remote), kDefaultDeviceId);
 
     delegate->OnPlayStream();
     delegate->GetControllerForTesting()->OnError();
@@ -504,10 +519,12 @@ class AudioOutputDelegateTest : public testing::Test {
     EXPECT_CALL(mirroring_manager_,
                 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull()));
     EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull()));
-    media::mojom::AudioOutputStreamObserverPtr observer_ptr;
-    auto observer_binding = CreateObserverBinding(&observer_ptr);
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStartPlaying()).Times(0);
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStopPlaying()).Times(0);
+    mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+        observer_remote;
+    auto observer_receiver = CreateObserverReceiver(&observer_remote);
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStartPlaying())
+        .Times(0);
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStopPlaying()).Times(0);
 
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
@@ -517,7 +534,7 @@ class AudioOutputDelegateTest : public testing::Test {
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), CreateDummyMojoAudioLog(), &media_observer_,
           kStreamId, kRenderFrameId, kRenderProcessId, Params(),
-          std::move(observer_ptr), kDefaultDeviceId);
+          std::move(observer_remote), kDefaultDeviceId);
     }
     SyncWithAllThreads();
     base::PostTask(FROM_HERE, {BrowserThread::UI}, std::move(done));
@@ -530,10 +547,12 @@ class AudioOutputDelegateTest : public testing::Test {
     EXPECT_CALL(mirroring_manager_,
                 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull()));
     EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull()));
-    media::mojom::AudioOutputStreamObserverPtr observer_ptr;
-    auto observer_binding = CreateObserverBinding(&observer_ptr);
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStartPlaying()).Times(0);
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStopPlaying()).Times(0);
+    mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+        observer_remote;
+    auto observer_receiver = CreateObserverReceiver(&observer_remote);
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStartPlaying())
+        .Times(0);
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStopPlaying()).Times(0);
 
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
@@ -543,7 +562,7 @@ class AudioOutputDelegateTest : public testing::Test {
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), CreateDummyMojoAudioLog(), &media_observer_,
           kStreamId, kRenderFrameId, kRenderProcessId, Params(),
-          std::move(observer_ptr), kDefaultDeviceId);
+          std::move(observer_remote), kDefaultDeviceId);
 
       SyncWithAllThreads();
 
@@ -560,10 +579,12 @@ class AudioOutputDelegateTest : public testing::Test {
     EXPECT_CALL(mirroring_manager_,
                 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull()));
     EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull()));
-    media::mojom::AudioOutputStreamObserverPtr observer_ptr;
-    auto observer_binding = CreateObserverBinding(&observer_ptr);
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStartPlaying()).Times(0);
-    EXPECT_CALL(GetMockObserver(&observer_binding), DidStopPlaying()).Times(0);
+    mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+        observer_remote;
+    auto observer_receiver = CreateObserverReceiver(&observer_remote);
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStartPlaying())
+        .Times(0);
+    EXPECT_CALL(GetMockObserver(&observer_receiver), DidStopPlaying()).Times(0);
 
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
@@ -573,7 +594,7 @@ class AudioOutputDelegateTest : public testing::Test {
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), CreateDummyMojoAudioLog(), &media_observer_,
           kStreamId, kRenderFrameId, kRenderProcessId, Params(),
-          std::move(observer_ptr), kDefaultDeviceId);
+          std::move(observer_remote), kDefaultDeviceId);
       SyncWithAllThreads();
 
       delegate.GetControllerForTesting()->OnError();

content/browser/renderer_host/media/old_render_frame_audio_output_stream_factory_unittest.cc

@@ -129,7 +129,8 @@ class MockContext : public RendererAudioOutputStreamFactoryContext {
       int render_frame_id,
       int stream_id,
       const media::AudioParameters& params,
-      media::mojom::AudioOutputStreamObserverPtr stream_observer,
+      mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+          stream_observer,
       media::AudioOutputDelegate::EventHandler* handler) override {
     EXPECT_NE(nullptr, delegate_);
     EXPECT_NE(nullptr, delegate_event_handler_location_);

content/browser/renderer_host/media/renderer_audio_output_stream_factory_context.h

@@ -12,6 +12,7 @@
 #include "content/common/content_export.h"
 #include "media/audio/audio_output_delegate.h"
 #include "media/mojo/mojom/audio_output_stream.mojom.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 
 namespace media {
 class AudioParameters;
@@ -44,7 +45,8 @@ class CONTENT_EXPORT RendererAudioOutputStreamFactoryContext {
       int render_frame_id,
       int stream_id,
       const media::AudioParameters& params,
-      media::mojom::AudioOutputStreamObserverPtr stream_observer,
+      mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+          stream_observer,
       media::AudioOutputDelegate::EventHandler* handler) = 0;
 };
 

content/browser/renderer_host/media/renderer_audio_output_stream_factory_context_impl.cc

@@ -56,7 +56,8 @@ RendererAudioOutputStreamFactoryContextImpl::CreateDelegate(
     int render_frame_id,
     int stream_id,
     const media::AudioParameters& params,
-    media::mojom::AudioOutputStreamObserverPtr stream_observer,
+    mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+        stream_observer,
     media::AudioOutputDelegate::EventHandler* handler) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   MediaObserver* const media_observer =

content/browser/renderer_host/media/renderer_audio_output_stream_factory_context_impl.h

@@ -12,6 +12,7 @@
 #include "content/browser/renderer_host/media/old_render_frame_audio_output_stream_factory.h"
 #include "content/browser/renderer_host/media/renderer_audio_output_stream_factory_context.h"
 #include "content/public/browser/browser_thread.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 
 namespace media {
 class AudioManager;
@@ -68,7 +69,8 @@ class CONTENT_EXPORT RendererAudioOutputStreamFactoryContextImpl
       int render_frame_id,
       int stream_id,
       const media::AudioParameters& params,
-      media::mojom::AudioOutputStreamObserverPtr stream_observer,
+      mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+          stream_observer,
       media::AudioOutputDelegate::EventHandler* handler) override;
 
  private:

media/mojo/services/mojo_audio_output_stream_provider.cc

@@ -22,7 +22,7 @@ MojoAudioOutputStreamProvider::MojoAudioOutputStreamProvider(
       create_delegate_callback_(std::move(create_delegate_callback)),
       deleter_callback_(std::move(deleter_callback)),
       observer_(std::move(observer)),
-      observer_binding_(observer_.get()) {
+      observer_receiver_(observer_.get()) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // Unretained is safe since |this| owns |binding_|.
   binding_.set_connection_error_handler(
@@ -60,12 +60,12 @@ void MojoAudioOutputStreamProvider::Acquire(
 
   provider_client_ = std::move(provider_client);
 
-  mojom::AudioOutputStreamObserverPtr observer_ptr;
-  observer_binding_.Bind(mojo::MakeRequest(&observer_ptr));
+  mojo::PendingRemote<mojom::AudioOutputStreamObserver> pending_observer;
+  observer_receiver_.Bind(pending_observer.InitWithNewPipeAndPassReceiver());
   // Unretained is safe since |this| owns |audio_output_|.
   audio_output_.emplace(
       base::BindOnce(std::move(create_delegate_callback_), params,
-                     std::move(observer_ptr)),
+                     std::move(pending_observer)),
       base::BindOnce(&mojom::AudioOutputStreamProviderClient::Created,
                      base::Unretained(provider_client_.get())),
       base::BindOnce(&MojoAudioOutputStreamProvider::CleanUp,

media/mojo/services/mojo_audio_output_stream_provider.h

@@ -14,6 +14,8 @@
 #include "media/mojo/services/media_mojo_export.h"
 #include "media/mojo/services/mojo_audio_output_stream.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 
 namespace media {
 
@@ -24,7 +26,7 @@ class MEDIA_MOJO_EXPORT MojoAudioOutputStreamProvider
   using CreateDelegateCallback =
       base::OnceCallback<std::unique_ptr<AudioOutputDelegate>(
           const AudioParameters& params,
-          mojom::AudioOutputStreamObserverPtr observer,
+          mojo::PendingRemote<mojom::AudioOutputStreamObserver>,
           AudioOutputDelegate::EventHandler*)>;
   using DeleterCallback = base::OnceCallback<void(AudioOutputStreamProvider*)>;
 
@@ -59,7 +61,7 @@ class MEDIA_MOJO_EXPORT MojoAudioOutputStreamProvider
   CreateDelegateCallback create_delegate_callback_;
   DeleterCallback deleter_callback_;
   std::unique_ptr<mojom::AudioOutputStreamObserver> observer_;
-  mojo::Binding<mojom::AudioOutputStreamObserver> observer_binding_;
+  mojo::Receiver<mojom::AudioOutputStreamObserver> observer_receiver_;
   base::Optional<MojoAudioOutputStream> audio_output_;
   mojom::AudioOutputStreamProviderClientPtr provider_client_;
 

media/mojo/services/mojo_audio_output_stream_provider_unittest.cc

@@ -44,8 +44,10 @@ class FakeObserver : public mojom::AudioOutputStreamObserver {
 
 class FakeDelegate : public AudioOutputDelegate {
  public:
-  explicit FakeDelegate(mojom::AudioOutputStreamObserverPtr observer)
-      : observer_(std::move(observer)) {}
+  explicit FakeDelegate(
+      mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+          pending_observer)
+      : observer_(std::move(pending_observer)) {}
   ~FakeDelegate() override = default;
 
   int GetStreamId() override { return 0; }
@@ -55,14 +57,15 @@ class FakeDelegate : public AudioOutputDelegate {
   void OnSetVolume(double) override {}
 
  private:
-  mojom::AudioOutputStreamObserverPtr observer_;
+  mojo::PendingRemote<media::mojom::AudioOutputStreamObserver> observer_;
 };
 
 std::unique_ptr<AudioOutputDelegate> CreateFakeDelegate(
     const AudioParameters& params,
-    mojom::AudioOutputStreamObserverPtr observer,
+    mojo::PendingRemote<media::mojom::AudioOutputStreamObserver>
+        pending_observer,
     AudioOutputDelegate::EventHandler*) {
-  return std::make_unique<FakeDelegate>(std::move(observer));
+  return std::make_unique<FakeDelegate>(std::move(pending_observer));
 }
 
 }  // namespace