Convert AudioInputStream to new Mojo types

This CL converts AudioInputStream{Ptr, Request} in chrome,
components, content, media and services to the new Mojo type, and
uses pending_remote<AudioDecoderClient> in resource_provider.mojom
and renderer_audio_input_stream_factory.mojom.

Bug: 955171
Change-Id: I84dc6af48103eb289bb2db097037f99c17e0119c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1864660Reviewed-by: Ken Rockot <rockot@google.com>
Reviewed-by: Yuri Wiitala <miu@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Commit-Queue: Miyoung Shin <myid.shin@igalia.com>
Cr-Commit-Position: refs/heads/master@{#708562}

chrome/browser/media/cast_mirroring_service_host.cc

@@ -34,6 +34,7 @@
 #include "content/public/browser/service_process_host.h"
 #include "content/public/browser/video_capture_device_launcher.h"
 #include "content/public/browser/web_contents.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "services/network/public/mojom/network_service.mojom.h"
 #include "services/viz/public/mojom/gpu.mojom.h"
@@ -294,7 +295,7 @@ void CastMirroringServiceHost::CreateAudioStream(
       source_web_contents, params, total_segments,
       base::BindRepeating(
           [](mojo::PendingRemote<mojom::AudioStreamCreatorClient> client,
-             media::mojom::AudioInputStreamPtr stream,
+             mojo::PendingRemote<media::mojom::AudioInputStream> stream,
              media::mojom::AudioInputStreamClientRequest client_request,
              media::mojom::ReadOnlyAudioDataPipePtr data_pipe) {
             // TODO(crbug.com/1015488): Remove |initially_muted| argument from

chrome/browser/media/cast_mirroring_service_host_browsertest.cc

@@ -219,7 +219,7 @@ class CastMirroringServiceHostBrowserTest
 
   // mojom::AudioStreamCreatorClient mocks.
   MOCK_METHOD0(OnAudioStreamCreated, void());
-  void StreamCreated(media::mojom::AudioInputStreamPtr stream,
+  void StreamCreated(mojo::PendingRemote<media::mojom::AudioInputStream> stream,
                      media::mojom::AudioInputStreamClientRequest client_request,
                      media::mojom::ReadOnlyAudioDataPipePtr data_pipe,
                      bool initially_muted) override {

components/mirroring/mojom/resource_provider.mojom

@@ -17,7 +17,7 @@ import "services/viz/public/mojom/gpu.mojom";
 // lifetime of this client.
 interface AudioStreamCreatorClient {
   StreamCreated(
-      media.mojom.AudioInputStream stream,
+      pending_remote<media.mojom.AudioInputStream> stream,
       media.mojom.AudioInputStreamClient& client_request,
       media.mojom.ReadOnlyAudioDataPipe data_pipe,
       bool initially_muted);

components/mirroring/service/captured_audio_input.cc

@@ -59,7 +59,7 @@ void CapturedAudioInput::SetOutputDeviceForAec(
 }
 
 void CapturedAudioInput::StreamCreated(
-    media::mojom::AudioInputStreamPtr stream,
+    mojo::PendingRemote<media::mojom::AudioInputStream> stream,
     media::mojom::AudioInputStreamClientRequest client_request,
     media::mojom::ReadOnlyAudioDataPipePtr data_pipe,
     bool initially_muted) {
@@ -68,7 +68,7 @@ void CapturedAudioInput::StreamCreated(
   DCHECK(!stream_);
   DCHECK(!stream_client_binding_.is_bound());
 
-  stream_ = std::move(stream);
+  stream_.Bind(std::move(stream));
   stream_client_binding_.Bind(std::move(client_request));
 
   base::PlatformFile socket_handle;

components/mirroring/service/captured_audio_input.h

@@ -13,7 +13,9 @@
 #include "media/audio/audio_input_ipc.h"
 #include "media/mojo/mojom/audio_input_stream.mojom.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/receiver.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace mirroring {
 
@@ -43,7 +45,7 @@ class COMPONENT_EXPORT(MIRRORING_SERVICE) CapturedAudioInput final
   void SetOutputDeviceForAec(const std::string& output_device_id) override;
 
   // mojom::AudioStreamCreatorClient implementation
-  void StreamCreated(media::mojom::AudioInputStreamPtr stream,
+  void StreamCreated(mojo::PendingRemote<media::mojom::AudioInputStream> stream,
                      media::mojom::AudioInputStreamClientRequest client_request,
                      media::mojom::ReadOnlyAudioDataPipePtr data_pipe,
                      bool initially_muted) override;
@@ -59,7 +61,7 @@ class COMPONENT_EXPORT(MIRRORING_SERVICE) CapturedAudioInput final
   mojo::Receiver<mojom::AudioStreamCreatorClient>
       stream_creator_client_receiver_{this};
   media::AudioInputIPCDelegate* delegate_ = nullptr;
-  media::mojom::AudioInputStreamPtr stream_;
+  mojo::Remote<media::mojom::AudioInputStream> stream_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturedAudioInput);
 };

components/mirroring/service/captured_audio_input_unittest.cc

@@ -10,8 +10,9 @@
 #include "base/test/task_environment.h"
 #include "media/base/audio_parameters.h"
 #include "media/mojo/mojom/audio_data_pipe.mojom.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/remote.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "mojo/public/cpp/system/buffer.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -61,18 +62,19 @@ class CapturedAudioInputTest : public ::testing::Test {
       uint32_t total_segments) {
     EXPECT_EQ(base::SyncSocket::kInvalidHandle, socket_.handle());
     EXPECT_FALSE(stream_);
-    media::mojom::AudioInputStreamPtr stream_ptr;
+    mojo::PendingRemote<media::mojom::AudioInputStream> pending_stream;
     auto input_stream = std::make_unique<MockStream>();
     stream_ = input_stream.get();
-    mojo::MakeStrongBinding(std::move(input_stream),
-                            mojo::MakeRequest(&stream_ptr));
+    mojo::MakeSelfOwnedReceiver(
+        std::move(input_stream),
+        pending_stream.InitWithNewPipeAndPassReceiver());
     base::CancelableSyncSocket foreign_socket;
     EXPECT_TRUE(
         base::CancelableSyncSocket::CreatePair(&socket_, &foreign_socket));
     mojo::Remote<mojom::AudioStreamCreatorClient> audio_client(
         std::move(client));
     audio_client->StreamCreated(
-        std::move(stream_ptr), mojo::MakeRequest(&stream_client_),
+        std::move(pending_stream), mojo::MakeRequest(&stream_client_),
         {base::in_place, base::ReadOnlySharedMemoryRegion::Create(1024).region,
          mojo::WrapPlatformFile(foreign_socket.Release())},
         initially_muted);

content/browser/media/audio_input_stream_broker.cc

@@ -206,8 +206,7 @@ void AudioInputStreamBroker::StreamCreated(
   DCHECK(stream_id.has_value());
   DCHECK(renderer_factory_client_);
   renderer_factory_client_->StreamCreated(
-      media::mojom::AudioInputStreamPtr(media::mojom::AudioInputStreamPtrInfo(
-          stream.PassPipe(), stream.version())),
+      std::move(stream),
       media::mojom::AudioInputStreamClientRequest(
           pending_client_receiver_.PassPipe()),
       std::move(data_pipe), initially_muted, stream_id);

content/browser/media/audio_input_stream_broker_unittest.cc

@@ -11,6 +11,8 @@
 #include "base/test/mock_callback.h"
 #include "content/public/test/browser_task_environment.h"
 #include "media/mojo/mojom/audio_input_stream.mojom.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/system/platform_handle.h"
@@ -55,13 +57,13 @@ class MockRendererAudioInputStreamFactoryClient
   MOCK_METHOD0(OnStreamCreated, void());
 
   void StreamCreated(
-      media::mojom::AudioInputStreamPtr input_stream,
+      mojo::PendingRemote<media::mojom::AudioInputStream> input_stream,
       media::mojom::AudioInputStreamClientRequest client_request,
       media::mojom::ReadOnlyAudioDataPipePtr data_pipe,
       bool initially_muted,
       const base::Optional<base::UnguessableToken>& stream_id) override {
     EXPECT_TRUE(stream_id.has_value());
-    input_stream_ = std::move(input_stream);
+    input_stream_.Bind(std::move(input_stream));
     client_request_ = std::move(client_request);
     OnStreamCreated();
   }
@@ -70,7 +72,7 @@ class MockRendererAudioInputStreamFactoryClient
 
  private:
   mojo::Receiver<mojom::RendererAudioInputStreamFactoryClient> receiver_{this};
-  media::mojom::AudioInputStreamPtr input_stream_;
+  mojo::Remote<media::mojom::AudioInputStream> input_stream_;
   media::mojom::AudioInputStreamClientRequest client_request_;
   DISALLOW_COPY_AND_ASSIGN(MockRendererAudioInputStreamFactoryClient);
 };
@@ -89,7 +91,7 @@ class MockStreamFactory : public audio::FakeStreamFactory {
         : device_id(device_id), params(params) {}
 
     bool requested = false;
-    media::mojom::AudioInputStreamRequest stream_request;
+    mojo::PendingReceiver<media::mojom::AudioInputStream> stream_receiver;
     media::mojom::AudioInputStreamClientPtr client;
     media::mojom::AudioInputStreamObserverPtr observer;
     media::mojom::AudioLogPtr log;
@@ -123,7 +125,7 @@ class MockStreamFactory : public audio::FakeStreamFactory {
     EXPECT_EQ(stream_request_data_->device_id, device_id);
     EXPECT_TRUE(stream_request_data_->params.Equals(params));
     stream_request_data_->requested = true;
-    stream_request_data_->stream_request = std::move(stream_receiver);
+    stream_request_data_->stream_receiver = std::move(stream_receiver);
     stream_request_data_->client.Bind(std::move(client));
     stream_request_data_->observer.Bind(std::move(observer));
     stream_request_data_->log.Bind(std::move(log));

content/browser/media/audio_loopback_stream_broker.cc

@@ -75,9 +75,9 @@ void AudioLoopbackStreamBroker::CreateStream(
   media::mojom::AudioInputStreamClientPtr client;
   client_request_ = mojo::MakeRequest(&client);
 
-  media::mojom::AudioInputStreamPtr stream;
-  media::mojom::AudioInputStreamRequest stream_request =
-      mojo::MakeRequest(&stream);
+  mojo::PendingRemote<media::mojom::AudioInputStream> stream;
+  mojo::PendingReceiver<media::mojom::AudioInputStream> stream_receiver =
+      stream.InitWithNewPipeAndPassReceiver();
 
   media::mojom::AudioInputStreamObserverPtr observer_ptr;
   observer_binding_.Bind(mojo::MakeRequest(&observer_ptr));
@@ -87,7 +87,7 @@ void AudioLoopbackStreamBroker::CreateStream(
       &AudioLoopbackStreamBroker::Cleanup, base::Unretained(this)));
 
   factory->CreateLoopbackStream(
-      std::move(stream_request), client.PassInterface(),
+      std::move(stream_receiver), client.PassInterface(),
       observer_ptr.PassInterface(), params_, shared_memory_count_,
       source_->GetGroupID(),
       base::BindOnce(&AudioLoopbackStreamBroker::StreamCreated,
@@ -106,7 +106,7 @@ void AudioLoopbackStreamBroker::DidStartRecording() {
 }
 
 void AudioLoopbackStreamBroker::StreamCreated(
-    media::mojom::AudioInputStreamPtr stream,
+    mojo::PendingRemote<media::mojom::AudioInputStream> stream,
     media::mojom::ReadOnlyAudioDataPipePtr data_pipe) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 

content/browser/media/audio_loopback_stream_broker.h

@@ -59,7 +59,7 @@ class CONTENT_EXPORT AudioLoopbackStreamBroker final
   void OnSourceGone() final;
 
  private:
-  void StreamCreated(media::mojom::AudioInputStreamPtr stream,
+  void StreamCreated(mojo::PendingRemote<media::mojom::AudioInputStream> stream,
                      media::mojom::ReadOnlyAudioDataPipePtr data_pipe);
   void Cleanup();
 

content/browser/media/audio_loopback_stream_broker_unittest.cc

@@ -12,6 +12,8 @@
 #include "content/public/test/browser_task_environment.h"
 #include "media/mojo/mojom/audio_input_stream.mojom.h"
 #include "mojo/public/cpp/bindings/pending_associated_receiver.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/system/platform_handle.h"
@@ -70,14 +72,14 @@ class MockRendererAudioInputStreamFactoryClient
   MOCK_METHOD0(OnStreamCreated, void());
 
   void StreamCreated(
-      media::mojom::AudioInputStreamPtr input_stream,
+      mojo::PendingRemote<media::mojom::AudioInputStream> input_stream,
       media::mojom::AudioInputStreamClientRequest client_request,
       media::mojom::ReadOnlyAudioDataPipePtr data_pipe,
       bool initially_muted,
       const base::Optional<base::UnguessableToken>& stream_id) override {
     // Loopback streams have no stream ids.
     EXPECT_FALSE(stream_id.has_value());
-    input_stream_ = std::move(input_stream);
+    input_stream_.Bind(std::move(input_stream));
     client_request_ = std::move(client_request);
     OnStreamCreated();
   }
@@ -86,7 +88,7 @@ class MockRendererAudioInputStreamFactoryClient
 
  private:
   mojo::Receiver<mojom::RendererAudioInputStreamFactoryClient> receiver_{this};
-  media::mojom::AudioInputStreamPtr input_stream_;
+  mojo::Remote<media::mojom::AudioInputStream> input_stream_;
   media::mojom::AudioInputStreamClientRequest client_request_;
 };
 
@@ -104,7 +106,7 @@ class MockStreamFactory : public audio::FakeStreamFactory {
         : params(params), group_id(group_id) {}
 
     bool requested = false;
-    media::mojom::AudioInputStreamRequest stream_request;
+    mojo::PendingReceiver<media::mojom::AudioInputStream> stream_receiver;
     media::mojom::AudioInputStreamClientPtr client;
     media::mojom::AudioInputStreamObserverPtr observer;
     const media::AudioParameters params;
@@ -135,7 +137,7 @@ class MockStreamFactory : public audio::FakeStreamFactory {
     EXPECT_EQ(stream_request_data_->group_id, group_id);
     EXPECT_TRUE(stream_request_data_->params.Equals(params));
     stream_request_data_->requested = true;
-    stream_request_data_->stream_request = std::move(receiver);
+    stream_request_data_->stream_receiver = std::move(receiver);
     stream_request_data_->client.Bind(std::move(client));
     stream_request_data_->observer.Bind(std::move(observer));
     stream_request_data_->shared_memory_count = shared_memory_count;

content/browser/media/in_process_audio_loopback_stream_creator.cc

@@ -44,7 +44,7 @@ class StreamCreatedCallbackAdapter final
 
   // mojom::RendererAudioInputStreamFactoryClient implementation.
   void StreamCreated(
-      media::mojom::AudioInputStreamPtr stream,
+      mojo::PendingRemote<media::mojom::AudioInputStream> stream,
       media::mojom::AudioInputStreamClientRequest client_request,
       media::mojom::ReadOnlyAudioDataPipePtr data_pipe,
       bool initially_muted,

content/browser/renderer_host/media/audio_input_stream_handle.cc

@@ -32,9 +32,8 @@ AudioInputStreamHandle::AudioInputStreamHandle(
     : stream_id_(base::UnguessableToken::Create()),
       deleter_callback_(std::move(deleter_callback)),
       client_remote_(std::move(client_pending_remote)),
-      stream_ptr_(),
       stream_client_request_(),
-      stream_(mojo::MakeRequest(&stream_ptr_),
+      stream_(pending_stream_.InitWithNewPipeAndPassReceiver(),
               CreatePtrAndStoreRequest(&stream_client_request_),
               std::move(create_delegate_callback),
               base::BindOnce(&AudioInputStreamHandle::OnCreated,
@@ -66,7 +65,7 @@ void AudioInputStreamHandle::OnCreated(
   DCHECK(deleter_callback_)
       << "|deleter_callback_| was called, but |this| hasn't been destructed!";
   client_remote_->StreamCreated(
-      std::move(stream_ptr_), std::move(stream_client_request_),
+      std::move(pending_stream_), std::move(stream_client_request_),
       std::move(data_pipe), initially_muted, stream_id_);
 }
 

content/browser/renderer_host/media/audio_input_stream_handle.h

@@ -49,7 +49,7 @@ class CONTENT_EXPORT AudioInputStreamHandle {
   const base::UnguessableToken stream_id_;
   DeleterCallback deleter_callback_;
   mojo::Remote<mojom::RendererAudioInputStreamFactoryClient> client_remote_;
-  media::mojom::AudioInputStreamPtr stream_ptr_;
+  mojo::PendingRemote<media::mojom::AudioInputStream> pending_stream_;
   media::mojom::AudioInputStreamClientRequest stream_client_request_;
   media::MojoAudioInputStream stream_;
 

content/browser/renderer_host/media/audio_input_stream_handle_unittest.cc

@@ -16,6 +16,7 @@
 #include "media/audio/audio_input_delegate.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/receiver.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -48,19 +49,19 @@ class MockRendererAudioInputStreamFactoryClient
   MOCK_METHOD0(Created, void());
 
   void StreamCreated(
-      media::mojom::AudioInputStreamPtr input_stream,
+      mojo::PendingRemote<media::mojom::AudioInputStream> input_stream,
       media::mojom::AudioInputStreamClientRequest client_request,
       media::mojom::ReadOnlyAudioDataPipePtr data_pipe,
       bool initially_muted,
       const base::Optional<base::UnguessableToken>& stream_id) override {
     EXPECT_TRUE(stream_id.has_value());
-    input_stream_ = std::move(input_stream);
+    input_stream_.Bind(std::move(input_stream));
     client_request_ = std::move(client_request);
     Created();
   }
 
  private:
-  media::mojom::AudioInputStreamPtr input_stream_;
+  mojo::Remote<media::mojom::AudioInputStream> input_stream_;
   media::mojom::AudioInputStreamClientRequest client_request_;
 };
 

content/browser/renderer_host/media/old_render_frame_audio_input_stream_factory_unittest.cc

@@ -80,7 +80,7 @@ class MockRendererAudioInputStreamFactoryClient
   MOCK_METHOD0(Created, void());
 
   void StreamCreated(
-      media::mojom::AudioInputStreamPtr input_stream,
+      mojo::PendingRemote<media::mojom::AudioInputStream> input_stream,
       media::mojom::AudioInputStreamClientRequest client_request,
       media::mojom::ReadOnlyAudioDataPipePtr data_pipe,
       bool initially_muted,
@@ -150,7 +150,6 @@ class OldOldRenderFrameAudioInputStreamFactoryTest : public testing::Test {
   MediaStreamManager media_stream_manager_;
 
   mojo::Remote<mojom::RendererAudioInputStreamFactory> factory_remote_;
-  media::mojom::AudioInputStreamPtr stream_ptr_;
   MockRendererAudioInputStreamFactoryClient client_;
   mojo::PendingRemote<mojom::RendererAudioInputStreamFactoryClient>
       client_pending_remote_;

content/browser/renderer_host/media/render_frame_audio_input_stream_factory_unittest.cc

@@ -144,7 +144,7 @@ class MAYBE_RenderFrameAudioInputStreamFactoryTest
       : public mojom::RendererAudioInputStreamFactoryClient {
    public:
     void StreamCreated(
-        media::mojom::AudioInputStreamPtr stream,
+        mojo::PendingRemote<media::mojom::AudioInputStream> stream,
         media::mojom::AudioInputStreamClientRequest client_request,
         media::mojom::ReadOnlyAudioDataPipePtr data_pipe,
         bool initially_muted,

content/common/media/renderer_audio_input_stream_factory.mojom

@@ -44,7 +44,7 @@ interface RendererAudioInputStreamFactoryClient {
   // process hosting it crashing, this function should be called again with a
   // fresh stream.
   StreamCreated(
-      media.mojom.AudioInputStream stream,
+      pending_remote<media.mojom.AudioInputStream> stream,
       media.mojom.AudioInputStreamClient& client_request,
       media.mojom.ReadOnlyAudioDataPipe data_pipe,
       bool initially_muted,

content/public/browser/audio_loopback_stream_creator.h

@@ -9,6 +9,7 @@
 #include "content/common/content_export.h"
 #include "media/mojo/mojom/audio_data_pipe.mojom.h"
 #include "media/mojo/mojom/audio_input_stream.mojom.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 
 namespace media {
 class AudioParameters;
@@ -30,7 +31,7 @@ class CONTENT_EXPORT AudioLoopbackStreamCreator {
 
   // The callback that is called when the requested stream is created.
   using StreamCreatedCallback = base::RepeatingCallback<void(
-      media::mojom::AudioInputStreamPtr stream,
+      mojo::PendingRemote<media::mojom::AudioInputStream> stream,
       media::mojom::AudioInputStreamClientRequest client_request,
       media::mojom::ReadOnlyAudioDataPipePtr data_pipe)>;
 

content/renderer/media/audio/mojo_audio_input_ipc.cc

@@ -109,7 +109,7 @@ void MojoAudioInputIPC::StopEchoCancellationDump() {
 }
 
 void MojoAudioInputIPC::StreamCreated(
-    media::mojom::AudioInputStreamPtr stream,
+    mojo::PendingRemote<media::mojom::AudioInputStream> stream,
     media::mojom::AudioInputStreamClientRequest stream_client_request,
     media::mojom::ReadOnlyAudioDataPipePtr data_pipe,
     bool initially_muted,
@@ -122,7 +122,7 @@ void MojoAudioInputIPC::StreamCreated(
   UMA_HISTOGRAM_TIMES("Media.Audio.Render.InputDeviceStreamCreationTime",
                       base::TimeTicks::Now() - stream_creation_start_time_);
 
-  stream_ = std::move(stream);
+  stream_.Bind(std::move(stream));
   stream_client_binding_.Bind(std::move(stream_client_request));
 
   // Keep the stream_id, if we get one. Regular input stream have stream ids,

content/renderer/media/audio/mojo_audio_input_ipc.h

@@ -76,7 +76,7 @@ class CONTENT_EXPORT MojoAudioInputIPC
 
  private:
   void StreamCreated(
-      media::mojom::AudioInputStreamPtr stream,
+      mojo::PendingRemote<media::mojom::AudioInputStream> stream,
       media::mojom::AudioInputStreamClientRequest stream_client_request,
       media::mojom::ReadOnlyAudioDataPipePtr data_pipe,
       bool initially_muted,
@@ -91,7 +91,7 @@ class CONTENT_EXPORT MojoAudioInputIPC
   StreamCreatorCB stream_creator_;
   StreamAssociatorCB stream_associator_;
 
-  media::mojom::AudioInputStreamPtr stream_;
+  mojo::Remote<media::mojom::AudioInputStream> stream_;
   mojo::Remote<audio::mojom::AudioProcessorControls> processor_controls_;
   // Initialized on StreamCreated.
   base::Optional<base::UnguessableToken> stream_id_;

content/renderer/media/audio/mojo_audio_input_ipc_unittest.cc

@@ -17,9 +17,9 @@
 #include "media/audio/audio_device_description.h"
 #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/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/system/buffer.h"
 #include "mojo/public/cpp/system/platform_handle.h"
@@ -79,7 +79,9 @@ class FakeStreamCreator {
  public:
   FakeStreamCreator(media::mojom::AudioInputStream* stream,
                     bool initially_muted)
-      : stream_(stream), binding_(stream_), initially_muted_(initially_muted) {}
+      : stream_(stream),
+        receiver_(stream_),
+        initially_muted_(initially_muted) {}
 
   void Create(const media::AudioSourceParameters& source_params,
               mojo::PendingRemote<mojom::RendererAudioInputStreamFactoryClient>
@@ -89,18 +91,17 @@ class FakeStreamCreator {
               const media::AudioParameters& params,
               bool automatic_gain_control,
               uint32_t total_segments) {
-    EXPECT_FALSE(binding_.is_bound());
+    EXPECT_FALSE(receiver_.is_bound());
     EXPECT_NE(stream_, nullptr);
     EXPECT_EQ(source_params.session_id, SourceParams().session_id);
     factory_client_.reset();
     factory_client_.Bind(std::move(factory_client));
-    media::mojom::AudioInputStreamPtr stream_ptr;
-    binding_.Bind(mojo::MakeRequest(&stream_ptr));
     base::CancelableSyncSocket foreign_socket;
     EXPECT_TRUE(
         base::CancelableSyncSocket::CreatePair(&socket_, &foreign_socket));
     factory_client_->StreamCreated(
-        std::move(stream_ptr), mojo::MakeRequest(&stream_client_),
+        receiver_.BindNewPipeAndPassRemote(),
+        mojo::MakeRequest(&stream_client_),
         {base::in_place,
          base::ReadOnlySharedMemoryRegion::Create(kMemoryLength).region,
          mojo::WrapPlatformFile(foreign_socket.Release())},
@@ -113,8 +114,7 @@ class FakeStreamCreator {
   }
 
   void Rearm() {
-    if (binding_.is_bound())
-      binding_.Unbind();
+    receiver_.reset();
     socket_.Close();
   }
 
@@ -127,7 +127,7 @@ class FakeStreamCreator {
   media::mojom::AudioInputStream* stream_;
   media::mojom::AudioInputStreamClientPtr stream_client_;
   mojo::Remote<mojom::RendererAudioInputStreamFactoryClient> factory_client_;
-  mojo::Binding<media::mojom::AudioInputStream> binding_;
+  mojo::Receiver<media::mojom::AudioInputStream> receiver_;
   bool initially_muted_;
   base::CancelableSyncSocket socket_;
 };

media/mojo/services/mojo_audio_input_stream.cc

@@ -16,20 +16,20 @@
 namespace media {
 
 MojoAudioInputStream::MojoAudioInputStream(
-    mojom::AudioInputStreamRequest request,
+    mojo::PendingReceiver<mojom::AudioInputStream> receiver,
     mojom::AudioInputStreamClientPtr client,
     CreateDelegateCallback create_delegate_callback,
     StreamCreatedCallback stream_created_callback,
     base::OnceClosure deleter_callback)
     : stream_created_callback_(std::move(stream_created_callback)),
       deleter_callback_(std::move(deleter_callback)),
-      binding_(this, std::move(request)),
+      receiver_(this, std::move(receiver)),
       client_(std::move(client)) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(stream_created_callback_);
   DCHECK(deleter_callback_);
-  // |this| owns |binding_|, so unretained is safe.
-  binding_.set_connection_error_handler(
+  // |this| owns |receiver_|, so unretained is safe.
+  receiver_.set_disconnect_handler(
       base::BindOnce(&MojoAudioInputStream::OnError, base::Unretained(this)));
   client_.set_connection_error_handler(
       base::BindOnce(&MojoAudioInputStream::OnError, base::Unretained(this)));
@@ -37,7 +37,7 @@ MojoAudioInputStream::MojoAudioInputStream(
   if (!delegate_) {
     // Failed to initialize the stream. We cannot call |deleter_callback_| yet,
     // since construction isn't done.
-    binding_.Close();
+    receiver_.reset();
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::BindOnce(&MojoAudioInputStream::OnStreamError,

media/mojo/services/mojo_audio_input_stream.h

@@ -13,7 +13,8 @@
 #include "media/mojo/mojom/audio_data_pipe.mojom.h"
 #include "media/mojo/mojom/audio_input_stream.mojom.h"
 #include "media/mojo/services/media_mojo_export.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 
 namespace media {
 
@@ -34,7 +35,7 @@ class MEDIA_MOJO_EXPORT MojoAudioInputStream
   // stream has been initialized. |deleter_callback| is called when this class
   // should be removed (stream ended/error). |deleter_callback| is required to
   // destroy |this| synchronously.
-  MojoAudioInputStream(mojom::AudioInputStreamRequest request,
+  MojoAudioInputStream(mojo::PendingReceiver<mojom::AudioInputStream> receiver,
                        mojom::AudioInputStreamClientPtr client,
                        CreateDelegateCallback create_delegate_callback,
                        StreamCreatedCallback stream_created_callback,
@@ -65,7 +66,7 @@ class MEDIA_MOJO_EXPORT MojoAudioInputStream
 
   StreamCreatedCallback stream_created_callback_;
   base::OnceClosure deleter_callback_;
-  mojo::Binding<AudioInputStream> binding_;
+  mojo::Receiver<AudioInputStream> receiver_;
   mojom::AudioInputStreamClientPtr client_;
   std::unique_ptr<AudioInputDelegate> delegate_;
   base::WeakPtrFactory<MojoAudioInputStream> weak_factory_{this};

media/mojo/services/mojo_audio_input_stream_unittest.cc

@@ -12,6 +12,8 @@
 #include "base/sync_socket.h"
 #include "base/test/task_environment.h"
 #include "media/audio/audio_input_controller.h"
+#include "mojo/public/cpp/bindings/binding.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"
@@ -35,7 +37,6 @@ using testing::SaveArg;
 using testing::StrictMock;
 using testing::Test;
 using AudioInputStream = mojom::AudioInputStream;
-using AudioInputStreamPtr = mojo::InterfacePtr<AudioInputStream>;
 
 class TestCancelableSyncSocket : public base::CancelableSyncSocket {
  public:
@@ -146,17 +147,17 @@ class MojoAudioInputStreamTest : public Test {
       : foreign_socket_(std::make_unique<TestCancelableSyncSocket>()),
         client_binding_(&client_, mojo::MakeRequest(&client_ptr_)) {}
 
-  AudioInputStreamPtr CreateAudioInput() {
-    AudioInputStreamPtr p;
+  mojo::Remote<mojom::AudioInputStream> CreateAudioInput() {
+    mojo::Remote<mojom::AudioInputStream> stream;
     ExpectDelegateCreation();
     impl_ = std::make_unique<MojoAudioInputStream>(
-        mojo::MakeRequest(&p), std::move(client_ptr_),
+        stream.BindNewPipeAndPassReceiver(), std::move(client_ptr_),
         base::BindOnce(&MockDelegateFactory::CreateDelegate,
                        base::Unretained(&mock_delegate_factory_)),
         base::BindOnce(&MockClient::Initialized, base::Unretained(&client_)),
         base::BindOnce(&MockDeleter::Finished, base::Unretained(&deleter_)));
-    EXPECT_TRUE(p.is_bound());
-    return p;
+    EXPECT_TRUE(stream.is_bound());
+    return stream;
   }
 
  protected:
@@ -191,9 +192,9 @@ class MojoAudioInputStreamTest : public Test {
 TEST_F(MojoAudioInputStreamTest, NoDelegate_SignalsError) {
   bool deleter_called = false;
   EXPECT_CALL(client_, OnError());
-  mojom::AudioInputStreamPtr stream_ptr;
+  mojo::Remote<mojom::AudioInputStream> stream_remote;
   MojoAudioInputStream stream(
-      mojo::MakeRequest(&stream_ptr), std::move(client_ptr_),
+      stream_remote.BindNewPipeAndPassReceiver(), std::move(client_ptr_),
       base::BindOnce(&CreateNoDelegate), base::BindOnce(&NotCalled),
       base::BindOnce([](bool* p) { *p = true; }, &deleter_called));
   EXPECT_FALSE(deleter_called)
@@ -203,23 +204,23 @@ TEST_F(MojoAudioInputStreamTest, NoDelegate_SignalsError) {
 }
 
 TEST_F(MojoAudioInputStreamTest, Record_Records) {
-  AudioInputStreamPtr audio_input_ptr = CreateAudioInput();
+  auto audio_input = CreateAudioInput();
   EXPECT_CALL(*delegate_, OnRecordStream());
 
-  audio_input_ptr->Record();
+  audio_input->Record();
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(MojoAudioInputStreamTest, SetVolume_SetsVolume) {
-  AudioInputStreamPtr audio_input_ptr = CreateAudioInput();
+  auto audio_input = CreateAudioInput();
   EXPECT_CALL(*delegate_, OnSetVolume(kNewVolume));
 
-  audio_input_ptr->SetVolume(kNewVolume);
+  audio_input->SetVolume(kNewVolume);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(MojoAudioInputStreamTest, DestructWithCallPending_Safe) {
-  AudioInputStreamPtr audio_input_ptr = CreateAudioInput();
+  auto audio_input = CreateAudioInput();
   EXPECT_CALL(client_, GotNotification(kInitiallyNotMuted));
   base::RunLoop().RunUntilIdle();
 
@@ -228,13 +229,13 @@ TEST_F(MojoAudioInputStreamTest, DestructWithCallPending_Safe) {
   delegate_event_handler_->OnStreamCreated(kStreamId, std::move(mem_),
                                            std::move(foreign_socket_),
                                            kInitiallyNotMuted);
-  audio_input_ptr->Record();
+  audio_input->Record();
   impl_.reset();
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(MojoAudioInputStreamTest, Created_NotifiesClient) {
-  AudioInputStreamPtr audio_input_ptr = CreateAudioInput();
+  auto audio_input = CreateAudioInput();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(client_, GotNotification(kInitiallyNotMuted));
@@ -249,27 +250,27 @@ TEST_F(MojoAudioInputStreamTest, Created_NotifiesClient) {
 }
 
 TEST_F(MojoAudioInputStreamTest, SetVolumeTooLarge_Error) {
-  AudioInputStreamPtr audio_input_ptr = CreateAudioInput();
+  auto audio_input = CreateAudioInput();
   EXPECT_CALL(deleter_, Finished());
   EXPECT_CALL(client_, OnError());
 
-  audio_input_ptr->SetVolume(15);
+  audio_input->SetVolume(15);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClear(&deleter_);
 }
 
 TEST_F(MojoAudioInputStreamTest, SetVolumeNegative_Error) {
-  AudioInputStreamPtr audio_input_ptr = CreateAudioInput();
+  auto audio_input = CreateAudioInput();
   EXPECT_CALL(deleter_, Finished());
   EXPECT_CALL(client_, OnError());
 
-  audio_input_ptr->SetVolume(-0.5);
+  audio_input->SetVolume(-0.5);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClear(&deleter_);
 }
 
 TEST_F(MojoAudioInputStreamTest, DelegateErrorBeforeCreated_PropagatesError) {
-  AudioInputStreamPtr audio_input_ptr = CreateAudioInput();
+  auto audio_input = CreateAudioInput();
   EXPECT_CALL(deleter_, Finished());
   EXPECT_CALL(client_, OnError());
 
@@ -281,7 +282,7 @@ TEST_F(MojoAudioInputStreamTest, DelegateErrorBeforeCreated_PropagatesError) {
 }
 
 TEST_F(MojoAudioInputStreamTest, DelegateErrorAfterCreated_PropagatesError) {
-  AudioInputStreamPtr audio_input_ptr = CreateAudioInput();
+  auto audio_input = CreateAudioInput();
   EXPECT_CALL(client_, GotNotification(kInitiallyNotMuted));
   EXPECT_CALL(deleter_, Finished());
   EXPECT_CALL(client_, OnError());
@@ -299,9 +300,9 @@ TEST_F(MojoAudioInputStreamTest, DelegateErrorAfterCreated_PropagatesError) {
 }
 
 TEST_F(MojoAudioInputStreamTest, RemoteEndGone_Error) {
-  AudioInputStreamPtr audio_input_ptr = CreateAudioInput();
+  auto audio_input = CreateAudioInput();
   EXPECT_CALL(deleter_, Finished());
-  audio_input_ptr.reset();
+  audio_input.reset();
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClear(&deleter_);
 }

services/audio/public/cpp/fake_stream_factory.h

@@ -11,7 +11,7 @@
 #include "base/run_loop.h"
 #include "media/mojo/mojom/audio_input_stream.mojom.h"
 #include "media/mojo/mojom/audio_logging.mojom.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "services/audio/public/mojom/audio_processing.mojom.h"
 #include "services/audio/public/mojom/stream_factory.mojom.h"