Migrate references to interfaces from video_decoder.mojom to new mojo types

Convert the remaining bits in both the browser and renderer processes
for the media::mojom::VideoDecoder, media::mojom::VideoDecoderClient and
media::mojom::VideoFrameHandleReleaser to the new mojo types.

Bug: 955171, 978694
Change-Id: Idbf067fa0d374ec8c52abd22774e9e2a29c4ed99
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1865214Reviewed-by: Jochen Eisinger <jochen@chromium.org>
Reviewed-by: Dominick Ng <dominickn@chromium.org>
Reviewed-by: Dan Sanders <sandersd@chromium.org>
Reviewed-by: Oksana Zhuravlova <oksamyt@chromium.org>
Commit-Queue: Mario Sanchez Prada <mario@igalia.com>
Cr-Commit-Position: refs/heads/master@{#707749}

chrome/browser/download/android/download_media_parser.cc

@@ -23,6 +23,7 @@
 #include "media/mojo/services/media_interface_provider.h"
 #include "media/renderers/paint_canvas_video_renderer.h"
 #include "media/video/gpu_video_accelerator_factories.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/viz/public/cpp/gpu/context_provider_command_buffer.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ -209,15 +210,16 @@ void DownloadMediaParser::OnGpuVideoAcceleratorFactoriesReady(
 }
 
 void DownloadMediaParser::DecodeVideoFrame() {
-  media::mojom::VideoDecoderPtr video_decoder_ptr;
+  mojo::PendingRemote<media::mojom::VideoDecoder> video_decoder_remote;
   GetMediaInterfaceFactory()->CreateVideoDecoder(
-      mojo::MakeRequest(&video_decoder_ptr));
+      video_decoder_remote.InitWithNewPipeAndPassReceiver());
 
   // Build and config the decoder.
   DCHECK(gpu_factories_);
   auto mojo_decoder = std::make_unique<media::MojoVideoDecoder>(
       base::ThreadTaskRunnerHandle::Get(), gpu_factories_.get(), this,
-      std::move(video_decoder_ptr), media::VideoDecoderImplementation::kDefault,
+      std::move(video_decoder_remote),
+      media::VideoDecoderImplementation::kDefault,
       base::BindRepeating(&OnRequestOverlayInfo), gfx::ColorSpace());
 
   decoder_ = std::make_unique<media::VideoThumbnailDecoder>(

content/browser/media/media_interface_proxy.cc

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

content/browser/media/media_interface_proxy.h

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

content/browser/media/video_decoder_proxy.cc

@@ -34,12 +34,12 @@ void VideoDecoderProxy::CreateAudioDecoder(
     mojo::PendingReceiver<media::mojom::AudioDecoder> receiver) {}
 
 void VideoDecoderProxy::CreateVideoDecoder(
-    media::mojom::VideoDecoderRequest request) {
+    mojo::PendingReceiver<media::mojom::VideoDecoder> receiver) {
   DVLOG(2) << __func__;
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   InterfaceFactory* factory = GetMediaInterfaceFactory();
   if (factory)
-    factory->CreateVideoDecoder(std::move(request));
+    factory->CreateVideoDecoder(std::move(receiver));
 }
 
 void VideoDecoderProxy::CreateDefaultRenderer(

content/browser/media/video_decoder_proxy.h

@@ -32,7 +32,8 @@ class VideoDecoderProxy : public media::mojom::InterfaceFactory {
   // media::mojom::InterfaceFactory implementation.
   void CreateAudioDecoder(
       mojo::PendingReceiver<media::mojom::AudioDecoder> receiver) final;
-  void CreateVideoDecoder(media::mojom::VideoDecoderRequest request) final;
+  void CreateVideoDecoder(
+      mojo::PendingReceiver<media::mojom::VideoDecoder> receiver) final;
   void CreateDefaultRenderer(const std::string& audio_device_id,
                              media::mojom::RendererRequest request) final;
 #if BUILDFLAG(ENABLE_CAST_RENDERER)

content/renderer/media/gpu/gpu_video_accelerator_factories_impl.cc

@@ -31,6 +31,7 @@
 #include "media/mojo/clients/mojo_video_encode_accelerator.h"
 #include "media/video/video_encode_accelerator.h"
 #include "mojo/public/cpp/base/shared_memory_utils.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/viz/public/cpp/gpu/context_provider_command_buffer.h"
 #include "third_party/skia/include/core/SkPostConfig.h"
 
@@ -129,7 +130,8 @@ void GpuVideoAcceleratorFactoriesImpl::BindOnTaskRunner(
   // (a) saves an ipc call, and (b) makes the return of those configs atomic.
   // Otherwise, we might have received configs for kDefault but not yet
   // kAlternate, for example.
-  interface_factory_->CreateVideoDecoder(mojo::MakeRequest(&video_decoder_));
+  interface_factory_->CreateVideoDecoder(
+      video_decoder_.BindNewPipeAndPassReceiver());
   video_decoder_->GetSupportedConfigs(base::BindOnce(
       &GpuVideoAcceleratorFactoriesImpl::OnSupportedDecoderConfigs,
       base::Unretained(this)));
@@ -236,8 +238,9 @@ GpuVideoAcceleratorFactoriesImpl::CreateVideoDecoder(
   if (CheckContextLost())
     return nullptr;
 
-  media::mojom::VideoDecoderPtr video_decoder;
-  interface_factory_->CreateVideoDecoder(mojo::MakeRequest(&video_decoder));
+  mojo::PendingRemote<media::mojom::VideoDecoder> video_decoder;
+  interface_factory_->CreateVideoDecoder(
+      video_decoder.InitWithNewPipeAndPassReceiver());
   return std::make_unique<media::MojoVideoDecoder>(
       task_runner_, this, media_log, std::move(video_decoder), implementation,
       request_overlay_info_cb, rendering_color_space_);

content/renderer/media/gpu/gpu_video_accelerator_factories_impl.h

@@ -27,6 +27,7 @@
 #include "media/mojo/mojom/video_encode_accelerator.mojom.h"
 #include "media/video/gpu_video_accelerator_factories.h"
 #include "media/video/supported_video_decoder_config.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace gpu {
@@ -178,7 +179,7 @@ class CONTENT_EXPORT GpuVideoAcceleratorFactoriesImpl
   media::mojom::VideoEncodeAcceleratorProviderPtr vea_provider_;
 
   // SupportedDecoderConfigs state.
-  mojo::InterfacePtr<media::mojom::VideoDecoder> video_decoder_;
+  mojo::Remote<media::mojom::VideoDecoder> video_decoder_;
   base::Lock supported_decoder_configs_lock_;
   // If the Optional is empty, then we have not yet gotten the configs.  If the
   // Optional contains an empty vector, then we have gotten the result and there

content/renderer/media/media_interface_factory.cc

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

content/renderer/media/media_interface_factory.h

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

media/mojo/clients/mojo_decoder_factory.cc

@@ -49,26 +49,29 @@ void MojoDecoderFactory::CreateVideoDecoders(
     const gfx::ColorSpace& target_color_space,
     std::vector<std::unique_ptr<VideoDecoder>>* video_decoders) {
 #if BUILDFLAG(ENABLE_MOJO_VIDEO_DECODER)
-  mojom::VideoDecoderPtr video_decoder_ptr;
 
 #if defined(OS_WIN)
   // If the D3D11VideoDecoder is enabled, then push a kAlternate decoder ahead
   // of the default one.
   if (base::FeatureList::IsEnabled(media::kD3D11VideoDecoder)) {
+    mojo::PendingRemote<mojom::VideoDecoder> d3d11_video_decoder_remote;
     interface_factory_->CreateVideoDecoder(
-        mojo::MakeRequest(&video_decoder_ptr));
+        d3d11_video_decoder_remote.InitWithNewPipeAndPassReceiver());
 
     video_decoders->push_back(std::make_unique<MojoVideoDecoder>(
-        task_runner, gpu_factories, media_log, std::move(video_decoder_ptr),
+        task_runner, gpu_factories, media_log,
+        std::move(d3d11_video_decoder_remote),
         VideoDecoderImplementation::kAlternate, request_overlay_info_cb,
         target_color_space));
   }
 #endif  // defined(OS_WIN)
-
-  interface_factory_->CreateVideoDecoder(mojo::MakeRequest(&video_decoder_ptr));
+  mojo::PendingRemote<mojom::VideoDecoder> d3d11_video_decoder_remote;
+  interface_factory_->CreateVideoDecoder(
+      d3d11_video_decoder_remote.InitWithNewPipeAndPassReceiver());
 
   video_decoders->push_back(std::make_unique<MojoVideoDecoder>(
-      task_runner, gpu_factories, media_log, std::move(video_decoder_ptr),
+      task_runner, gpu_factories, media_log,
+      std::move(d3d11_video_decoder_remote),
       VideoDecoderImplementation::kDefault, request_overlay_info_cb,
       target_color_space));
 

media/mojo/clients/mojo_video_decoder.cc

@@ -28,6 +28,9 @@
 #include "media/video/gpu_video_accelerator_factories.h"
 #include "media/video/video_decode_accelerator.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/pending_associated_remote.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/shared_remote.h"
 
 namespace media {
 namespace {
@@ -69,22 +72,22 @@ class MojoVideoFrameHandleReleaser
   REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
 
   MojoVideoFrameHandleReleaser(
-      mojom::VideoFrameHandleReleaserPtrInfo
-          video_frame_handle_releaser_ptr_info,
+      mojo::PendingRemote<mojom::VideoFrameHandleReleaser>
+          video_frame_handle_releaser_remote,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
     // Connection errors are not handled because we wouldn't do anything
     // differently. ("If a tree falls in a forest...")
     video_frame_handle_releaser_ =
-        mojom::ThreadSafeVideoFrameHandleReleaserPtr::Create(
-            std::move(video_frame_handle_releaser_ptr_info),
+        mojo::SharedRemote<mojom::VideoFrameHandleReleaser>(
+            std::move(video_frame_handle_releaser_remote),
             std::move(task_runner));
   }
 
   void ReleaseVideoFrame(const base::UnguessableToken& release_token,
                          const gpu::SyncToken& release_sync_token) {
     DVLOG(3) << __func__ << "(" << release_token << ")";
-    (*video_frame_handle_releaser_)
-        ->ReleaseVideoFrame(release_token, release_sync_token);
+    video_frame_handle_releaser_->ReleaseVideoFrame(release_token,
+                                                    release_sync_token);
   }
 
   // Create a ReleaseMailboxCB that calls Release(). Since the callback holds a
@@ -101,7 +104,7 @@ class MojoVideoFrameHandleReleaser
   friend class base::RefCountedThreadSafe<MojoVideoFrameHandleReleaser>;
   ~MojoVideoFrameHandleReleaser() {}
 
-  scoped_refptr<mojom::ThreadSafeVideoFrameHandleReleaserPtr>
+  mojo::SharedRemote<mojom::VideoFrameHandleReleaser>
       video_frame_handle_releaser_;
 
   DISALLOW_COPY_AND_ASSIGN(MojoVideoFrameHandleReleaser);
@@ -111,17 +114,16 @@ MojoVideoDecoder::MojoVideoDecoder(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     GpuVideoAcceleratorFactories* gpu_factories,
     MediaLog* media_log,
-    mojom::VideoDecoderPtr remote_decoder,
+    mojo::PendingRemote<mojom::VideoDecoder> pending_remote_decoder,
     VideoDecoderImplementation implementation,
     const RequestOverlayInfoCB& request_overlay_info_cb,
     const gfx::ColorSpace& target_color_space)
     : task_runner_(task_runner),
-      remote_decoder_info_(remote_decoder.PassInterface()),
+      pending_remote_decoder_(std::move(pending_remote_decoder)),
       gpu_factories_(gpu_factories),
       timestamps_(128),
       writer_capacity_(
           GetDefaultDecoderBufferConverterCapacity(DemuxerStream::VIDEO)),
-      client_binding_(this),
       media_log_service_(media_log),
       media_log_binding_(&media_log_service_),
       request_overlay_info_cb_(request_overlay_info_cb),
@@ -338,15 +340,17 @@ void MojoVideoDecoder::BindRemoteDecoder() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!remote_decoder_bound_);
 
-  remote_decoder_.Bind(std::move(remote_decoder_info_));
+  remote_decoder_.Bind(std::move(pending_remote_decoder_));
   remote_decoder_bound_ = true;
 
-  remote_decoder_.set_connection_error_handler(
+  remote_decoder_.set_disconnect_handler(
       base::Bind(&MojoVideoDecoder::Stop, base::Unretained(this)));
 
   // Create |client| interface (bound to |this|).
-  mojom::VideoDecoderClientAssociatedPtrInfo client_ptr_info;
-  client_binding_.Bind(mojo::MakeRequest(&client_ptr_info));
+  mojo::PendingAssociatedRemote<mojom::VideoDecoderClient>
+      client_pending_remote;
+  client_receiver_.Bind(
+      client_pending_remote.InitWithNewEndpointAndPassReceiver());
 
   // Create |media_log| interface (bound to |media_log_service_|).
   mojom::MediaLogAssociatedPtrInfo media_log_ptr_info;
@@ -380,7 +384,7 @@ void MojoVideoDecoder::BindRemoteDecoder() {
   }
 
   remote_decoder_->Construct(
-      std::move(client_ptr_info), std::move(media_log_ptr_info),
+      std::move(client_pending_remote), std::move(media_log_ptr_info),
       std::move(video_frame_handle_releaser_receiver),
       std::move(remote_consumer_handle), std::move(command_buffer_id),
       video_decoder_implementation_, target_color_space_);

media/mojo/clients/mojo_video_decoder.h

@@ -15,6 +15,9 @@
 #include "media/mojo/mojom/video_decoder.mojom.h"
 #include "media/video/video_decode_accelerator.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
+#include "mojo/public/cpp/bindings/associated_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "ui/gfx/color_space.h"
 
 namespace base {
@@ -35,13 +38,14 @@ class MojoVideoFrameHandleReleaser;
 class MojoVideoDecoder final : public VideoDecoder,
                                public mojom::VideoDecoderClient {
  public:
-  MojoVideoDecoder(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-                   GpuVideoAcceleratorFactories* gpu_factories,
-                   MediaLog* media_log,
-                   mojom::VideoDecoderPtr remote_decoder,
-                   VideoDecoderImplementation implementation,
-                   const RequestOverlayInfoCB& request_overlay_info_cb,
-                   const gfx::ColorSpace& target_color_space);
+  MojoVideoDecoder(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+      GpuVideoAcceleratorFactories* gpu_factories,
+      MediaLog* media_log,
+      mojo::PendingRemote<mojom::VideoDecoder> pending_remote_decoder,
+      VideoDecoderImplementation implementation,
+      const RequestOverlayInfoCB& request_overlay_info_cb,
+      const gfx::ColorSpace& target_color_space);
   ~MojoVideoDecoder() final;
 
   // VideoDecoder implementation.
@@ -91,7 +95,7 @@ class MojoVideoDecoder final : public VideoDecoder,
 
   // Used to pass the remote decoder from the constructor (on the main thread)
   // to Initialize() (on the media thread).
-  mojom::VideoDecoderPtrInfo remote_decoder_info_;
+  mojo::PendingRemote<mojom::VideoDecoder> pending_remote_decoder_;
 
   // Manages VideoFrame destruction callbacks.
   scoped_refptr<MojoVideoFrameHandleReleaser> mojo_video_frame_handle_releaser_;
@@ -109,14 +113,14 @@ class MojoVideoDecoder final : public VideoDecoder,
   // large enough to account for any amount of frame reordering.
   base::MRUCache<int64_t, base::TimeTicks> timestamps_;
 
-  mojom::VideoDecoderPtr remote_decoder_;
+  mojo::Remote<mojom::VideoDecoder> remote_decoder_;
   std::unique_ptr<MojoDecoderBufferWriter> mojo_decoder_buffer_writer_;
 
   uint32_t writer_capacity_ = 0;
 
   bool remote_decoder_bound_ = false;
   bool has_connection_error_ = false;
-  mojo::AssociatedBinding<mojom::VideoDecoderClient> client_binding_;
+  mojo::AssociatedReceiver<mojom::VideoDecoderClient> client_receiver_{this};
   MojoMediaLogService media_log_service_;
   mojo::AssociatedBinding<mojom::MediaLog> media_log_binding_;
   RequestOverlayInfoCB request_overlay_info_cb_;

media/mojo/mojom/interface_factory.mojom

@@ -18,7 +18,7 @@ import "mojo/public/mojom/base/unguessable_token.mojom";
 // ContentDecryptionModules created with the same factory.
 interface InterfaceFactory {
   CreateAudioDecoder(pending_receiver<AudioDecoder> audio_decoder);
-  CreateVideoDecoder(VideoDecoder& video_decoder);
+  CreateVideoDecoder(pending_receiver<VideoDecoder> video_decoder);
 
   // Creates a regular media::Renderer (DefaultRendererFactory).
   CreateDefaultRenderer(string audio_device_id, Renderer& renderer);

media/mojo/services/interface_factory_impl.cc

@@ -83,13 +83,12 @@ void InterfaceFactoryImpl::CreateAudioDecoder(
 }
 
 void InterfaceFactoryImpl::CreateVideoDecoder(
-    mojom::VideoDecoderRequest request) {
+    mojo::PendingReceiver<mojom::VideoDecoder> receiver) {
   DVLOG(2) << __func__;
 #if BUILDFLAG(ENABLE_MOJO_VIDEO_DECODER)
-  video_decoder_bindings_.AddBinding(
-      std::make_unique<MojoVideoDecoderService>(mojo_media_client_,
-                                                &cdm_service_context_),
-      std::move(request));
+  video_decoder_receivers_.Add(std::make_unique<MojoVideoDecoderService>(
+                                   mojo_media_client_, &cdm_service_context_),
+                               std::move(receiver));
 #endif  // BUILDFLAG(ENABLE_MOJO_VIDEO_DECODER)
 }
 
@@ -233,7 +232,7 @@ bool InterfaceFactoryImpl::IsEmpty() {
 #endif  // BUILDFLAG(ENABLE_MOJO_AUDIO_DECODER)
 
 #if BUILDFLAG(ENABLE_MOJO_VIDEO_DECODER)
-  if (!video_decoder_bindings_.empty())
+  if (!video_decoder_receivers_.empty())
     return false;
 #endif  // BUILDFLAG(ENABLE_MOJO_VIDEO_DECODER)
 
@@ -270,7 +269,7 @@ void InterfaceFactoryImpl::SetBindingConnectionErrorHandler() {
 #endif  // BUILDFLAG(ENABLE_MOJO_AUDIO_DECODER)
 
 #if BUILDFLAG(ENABLE_MOJO_VIDEO_DECODER)
-  video_decoder_bindings_.set_connection_error_handler(connection_error_cb);
+  video_decoder_receivers_.set_disconnect_handler(connection_error_cb);
 #endif  // BUILDFLAG(ENABLE_MOJO_VIDEO_DECODER)
 
 #if BUILDFLAG(ENABLE_MOJO_RENDERER)

media/mojo/services/interface_factory_impl.h

@@ -42,7 +42,8 @@ class InterfaceFactoryImpl : public DeferredDestroy<mojom::InterfaceFactory> {
   // mojom::InterfaceFactory implementation.
   void CreateAudioDecoder(
       mojo::PendingReceiver<mojom::AudioDecoder> receiver) final;
-  void CreateVideoDecoder(mojom::VideoDecoderRequest request) final;
+  void CreateVideoDecoder(
+      mojo::PendingReceiver<mojom::VideoDecoder> receiver) final;
   void CreateDefaultRenderer(const std::string& audio_device_id,
                              mojom::RendererRequest request) final;
 #if BUILDFLAG(ENABLE_CAST_RENDERER)
@@ -92,7 +93,7 @@ class InterfaceFactoryImpl : public DeferredDestroy<mojom::InterfaceFactory> {
 #endif  // BUILDFLAG(ENABLE_MOJO_AUDIO_DECODER)
 
 #if BUILDFLAG(ENABLE_MOJO_VIDEO_DECODER)
-  mojo::StrongBindingSet<mojom::VideoDecoder> video_decoder_bindings_;
+  mojo::UniqueReceiverSet<mojom::VideoDecoder> video_decoder_receivers_;
 #endif  // BUILDFLAG(ENABLE_MOJO_VIDEO_DECODER)
 
 #if BUILDFLAG(ENABLE_MOJO_RENDERER) || BUILDFLAG(ENABLE_CAST_RENDERER)

media/mojo/test/mojo_video_decoder_integration_test.cc

@@ -33,7 +33,9 @@
 #include "media/mojo/services/mojo_cdm_service_context.h"
 #include "media/mojo/services/mojo_media_client.h"
 #include "media/mojo/services/mojo_video_decoder_service.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/color_space.h"
@@ -207,12 +209,12 @@ class MojoVideoDecoderIntegrationTest : public ::testing::Test {
 
   void SetWriterCapacity(uint32_t capacity) { writer_capacity_ = capacity; }
 
-  mojom::VideoDecoderPtr CreateRemoteVideoDecoder() {
-    mojom::VideoDecoderPtr remote_video_decoder;
-    mojo::MakeStrongBinding(
+  mojo::PendingRemote<mojom::VideoDecoder> CreateRemoteVideoDecoder() {
+    mojo::PendingRemote<mojom::VideoDecoder> remote_video_decoder;
+    mojo::MakeSelfOwnedReceiver(
         std::make_unique<MojoVideoDecoderService>(&mojo_media_client_,
                                                   &mojo_cdm_service_context_),
-        mojo::MakeRequest(&remote_video_decoder));
+        remote_video_decoder.InitWithNewPipeAndPassReceiver());
     return remote_video_decoder;
   }
 
@@ -340,7 +342,8 @@ class MojoVideoDecoderIntegrationTest : public ::testing::Test {
 TEST_F(MojoVideoDecoderIntegrationTest, CreateAndDestroy) {}
 
 TEST_F(MojoVideoDecoderIntegrationTest, GetSupportedConfigs) {
-  mojom::VideoDecoderPtr remote_video_decoder = CreateRemoteVideoDecoder();
+  mojo::Remote<mojom::VideoDecoder> remote_video_decoder(
+      CreateRemoteVideoDecoder());
   StrictMock<
       base::MockCallback<mojom::VideoDecoder::GetSupportedConfigsCallback>>
       callback;