Replace Bind calls with BindRepeating or BindOnce, as appropriate.

Bug: 1007808
Change-Id: Icc6949f3d34dfea6c23f8494de05be38d72d739a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2518091Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Commit-Queue: David Bienvenu <davidbienvenu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#824638}

media/mojo/clients/mojo_android_overlay_unittest.cc

@@ -81,12 +81,12 @@ class MojoAndroidOverlayTest : public ::testing::Test {
   void SetUp() override {
     // Set up default config.
     config_.rect = gfx::Rect(100, 200, 300, 400);
-    config_.ready_cb = base::Bind(&MockClientCallbacks::OnReady,
-                                  base::Unretained(&callbacks_));
-    config_.failed_cb = base::Bind(&MockClientCallbacks::OnFailed,
-                                   base::Unretained(&callbacks_));
-    config_.power_cb = base::Bind(&MockClientCallbacks::OnPowerEfficient,
-                                  base::Unretained(&callbacks_));
+    config_.ready_cb = base::BindOnce(&MockClientCallbacks::OnReady,
+                                      base::Unretained(&callbacks_));
+    config_.failed_cb = base::BindOnce(&MockClientCallbacks::OnFailed,
+                                       base::Unretained(&callbacks_));
+    config_.power_cb = base::BindRepeating(
+        &MockClientCallbacks::OnPowerEfficient, base::Unretained(&callbacks_));
 
     // Make sure that we have an implementation of GpuSurfaceLookup.
     gpu::GpuSurfaceTracker::Get();

media/mojo/clients/mojo_decryptor_unittest.cc

@@ -147,8 +147,8 @@ TEST_F(MojoDecryptorTest, Reset_DuringDecryptAndDecode_Audio) {
 
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
   mojo_decryptor_->DecryptAndDecodeAudio(
-      std::move(buffer),
-      base::Bind(&MojoDecryptorTest::AudioDecoded, base::Unretained(this)));
+      std::move(buffer), base::BindRepeating(&MojoDecryptorTest::AudioDecoded,
+                                             base::Unretained(this)));
   mojo_decryptor_->ResetDecoder(Decryptor::kAudio);
   base::RunLoop().RunUntilIdle();
 }
@@ -170,8 +170,8 @@ TEST_F(MojoDecryptorTest, Reset_DuringDecryptAndDecode_Audio_ChunkedWrite) {
 
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
   mojo_decryptor_->DecryptAndDecodeAudio(
-      std::move(buffer),
-      base::Bind(&MojoDecryptorTest::AudioDecoded, base::Unretained(this)));
+      std::move(buffer), base::BindRepeating(&MojoDecryptorTest::AudioDecoded,
+                                             base::Unretained(this)));
   mojo_decryptor_->ResetDecoder(Decryptor::kAudio);
   base::RunLoop().RunUntilIdle();
 }
@@ -194,8 +194,8 @@ TEST_F(MojoDecryptorTest, Reset_DuringDecryptAndDecode_Video) {
 
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
   mojo_decryptor_->DecryptAndDecodeVideo(
-      std::move(buffer),
-      base::Bind(&MojoDecryptorTest::VideoDecoded, base::Unretained(this)));
+      std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
+                                             base::Unretained(this)));
   mojo_decryptor_->ResetDecoder(Decryptor::kVideo);
   base::RunLoop().RunUntilIdle();
 }
@@ -219,8 +219,8 @@ TEST_F(MojoDecryptorTest, Reset_DuringDecryptAndDecode_Video_ChunkedWrite) {
 
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
   mojo_decryptor_->DecryptAndDecodeVideo(
-      std::move(buffer),
-      base::Bind(&MojoDecryptorTest::VideoDecoded, base::Unretained(this)));
+      std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
+                                             base::Unretained(this)));
   mojo_decryptor_->ResetDecoder(Decryptor::kVideo);
   base::RunLoop().RunUntilIdle();
 }
@@ -258,11 +258,11 @@ TEST_F(MojoDecryptorTest, Reset_DuringDecryptAndDecode_AudioAndVideo) {
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
 
   mojo_decryptor_->DecryptAndDecodeAudio(
-      buffer,
-      base::Bind(&MojoDecryptorTest::AudioDecoded, base::Unretained(this)));
+      buffer, base::BindRepeating(&MojoDecryptorTest::AudioDecoded,
+                                  base::Unretained(this)));
   mojo_decryptor_->DecryptAndDecodeVideo(
-      std::move(buffer),
-      base::Bind(&MojoDecryptorTest::VideoDecoded, base::Unretained(this)));
+      std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
+                                             base::Unretained(this)));
   mojo_decryptor_->ResetDecoder(Decryptor::kAudio);
   mojo_decryptor_->ResetDecoder(Decryptor::kVideo);
   base::RunLoop().RunUntilIdle();
@@ -283,8 +283,8 @@ TEST_F(MojoDecryptorTest, VideoDecodeFreesBuffer) {
 
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
   mojo_decryptor_->DecryptAndDecodeVideo(
-      std::move(buffer),
-      base::Bind(&MojoDecryptorTest::VideoDecoded, base::Unretained(this)));
+      std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
+                                             base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 }
 
@@ -303,8 +303,8 @@ TEST_F(MojoDecryptorTest, VideoDecodeFreesMultipleBuffers) {
   for (int i = 0; i < TIMES; ++i) {
     scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
     mojo_decryptor_->DecryptAndDecodeVideo(
-        std::move(buffer),
-        base::Bind(&MojoDecryptorTest::VideoDecoded, base::Unretained(this)));
+        std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
+                                               base::Unretained(this)));
   }
   base::RunLoop().RunUntilIdle();
 }
@@ -327,8 +327,8 @@ TEST_F(MojoDecryptorTest, VideoDecodeHoldThenFreeBuffers) {
   for (int i = 0; i < 2; ++i) {
     scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
     mojo_decryptor_->DecryptAndDecodeVideo(
-        std::move(buffer),
-        base::Bind(&MojoDecryptorTest::VideoDecoded, base::Unretained(this)));
+        std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
+                                               base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
 
@@ -354,8 +354,8 @@ TEST_F(MojoDecryptorTest, EOSBuffer) {
 
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
   mojo_decryptor_->DecryptAndDecodeVideo(
-      std::move(buffer),
-      base::Bind(&MojoDecryptorTest::VideoDecoded, base::Unretained(this)));
+      std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
+                                             base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 }
 
@@ -376,8 +376,8 @@ TEST_F(MojoDecryptorTest, DestroyService) {
 
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
   mojo_decryptor_->DecryptAndDecodeVideo(
-      std::move(buffer),
-      base::Bind(&MojoDecryptorTest::VideoDecoded, base::Unretained(this)));
+      std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
+                                             base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 }
 

media/mojo/clients/mojo_demuxer_stream_impl.h

@@ -39,8 +39,8 @@ class MojoDemuxerStreamImpl : public mojom::DemuxerStream {
 
   // Sets an error handler that will be called if a connection error occurs on
   // the bound message pipe.
-  void set_disconnect_handler(const base::Closure& error_handler) {
-    receiver_.set_disconnect_handler(error_handler);
+  void set_disconnect_handler(base::OnceClosure error_handler) {
+    receiver_.set_disconnect_handler(std::move(error_handler));
   }
 
  private:

media/mojo/clients/mojo_renderer.cc

@@ -86,8 +86,8 @@ void MojoRenderer::InitializeRendererFromStreams(
     // Using base::Unretained(this) is safe because |this| owns |mojo_stream|,
     // and the error handler can't be invoked once |mojo_stream| is destroyed.
     mojo_stream->set_disconnect_handler(
-        base::Bind(&MojoRenderer::OnDemuxerStreamConnectionError,
-                   base::Unretained(this), mojo_stream.get()));
+        base::BindOnce(&MojoRenderer::OnDemuxerStreamConnectionError,
+                       base::Unretained(this), mojo_stream.get()));
 
     streams_.push_back(std::move(mojo_stream));
     stream_proxies.push_back(std::move(stream_proxy));

media/mojo/common/mojo_decoder_buffer_converter.cc

@@ -66,11 +66,11 @@ MojoDecoderBufferReader::MojoDecoderBufferReader(
       bytes_read_(0) {
   DVLOG(1) << __func__;
 
-  MojoResult result =
-      pipe_watcher_.Watch(consumer_handle_.get(), MOJO_HANDLE_SIGNAL_READABLE,
-                          MOJO_WATCH_CONDITION_SATISFIED,
-                          base::Bind(&MojoDecoderBufferReader::OnPipeReadable,
-                                     base::Unretained(this)));
+  MojoResult result = pipe_watcher_.Watch(
+      consumer_handle_.get(), MOJO_HANDLE_SIGNAL_READABLE,
+      MOJO_WATCH_CONDITION_SATISFIED,
+      base::BindRepeating(&MojoDecoderBufferReader::OnPipeReadable,
+                          base::Unretained(this)));
   if (result != MOJO_RESULT_OK) {
     DVLOG(1) << __func__
              << ": Failed to start watching the pipe. result=" << result;

media/mojo/services/gpu_mojo_media_client.cc

@@ -245,7 +245,7 @@ std::unique_ptr<VideoDecoder> GpuMojoMediaClient::CreateVideoDecoder(
   switch (implementation) {
     case VideoDecoderImplementation::kDefault: {
 #if defined(OS_ANDROID)
-      auto get_stub_cb = base::Bind(
+      auto get_stub_cb = base::BindRepeating(
           &GetCommandBufferStub, gpu_task_runner_, media_gpu_channel_manager_,
           command_buffer_id->channel_token, command_buffer_id->route_id);
       std::unique_ptr<SharedImageVideoProvider> image_provider;

media/mojo/services/interface_factory_impl.cc

@@ -108,7 +108,7 @@ void InterfaceFactoryImpl::CreateDefaultRenderer(
 
   // base::Unretained() is safe because the callback will be fired by
   // |mojo_renderer_service|, which is owned by |renderer_receivers_|.
-  mojo_renderer_service_ptr->set_bad_message_cb(base::Bind(
+  mojo_renderer_service_ptr->set_bad_message_cb(base::BindRepeating(
       base::IgnoreResult(&mojo::UniqueReceiverSet<mojom::Renderer>::Remove),
       base::Unretained(&renderer_receivers_), receiver_id));
 #endif  // BUILDFLAG(ENABLE_MOJO_RENDERER)

media/mojo/services/media_resource_shim.cc

@@ -21,8 +21,8 @@ MediaResourceShim::MediaResourceShim(
 
   for (auto& s : streams) {
     streams_.emplace_back(new MojoDemuxerStreamAdapter(
-        std::move(s), base::Bind(&MediaResourceShim::OnStreamReady,
-                                 weak_factory_.GetWeakPtr())));
+        std::move(s), base::BindOnce(&MediaResourceShim::OnStreamReady,
+                                     weak_factory_.GetWeakPtr())));
   }
 }
 

media/mojo/services/mojo_demuxer_stream_adapter.cc

@@ -19,9 +19,9 @@ namespace media {
 
 MojoDemuxerStreamAdapter::MojoDemuxerStreamAdapter(
     mojo::PendingRemote<mojom::DemuxerStream> demuxer_stream,
-    const base::Closure& stream_ready_cb)
+    base::OnceClosure stream_ready_cb)
     : demuxer_stream_(std::move(demuxer_stream)),
-      stream_ready_cb_(stream_ready_cb),
+      stream_ready_cb_(std::move(stream_ready_cb)),
       type_(UNKNOWN) {
   DVLOG(1) << __func__;
   demuxer_stream_->Initialize(base::BindOnce(
@@ -81,7 +81,7 @@ void MojoDemuxerStreamAdapter::OnStreamReady(
 
   UpdateConfig(std::move(audio_config), std::move(video_config));
 
-  stream_ready_cb_.Run();
+  std::move(stream_ready_cb_).Run();
 }
 
 void MojoDemuxerStreamAdapter::OnBufferReady(

media/mojo/services/mojo_demuxer_stream_adapter.h

@@ -35,7 +35,7 @@ class MojoDemuxerStreamAdapter : public DemuxerStream {
   // NOTE: Illegal to call any methods until |stream_ready_cb| is invoked.
   MojoDemuxerStreamAdapter(
       mojo::PendingRemote<mojom::DemuxerStream> demuxer_stream,
-      const base::Closure& stream_ready_cb);
+      base::OnceClosure stream_ready_cb);
   ~MojoDemuxerStreamAdapter() override;
 
   // DemuxerStream implementation.
@@ -66,7 +66,7 @@ class MojoDemuxerStreamAdapter : public DemuxerStream {
 
   // See constructor for descriptions.
   mojo::Remote<mojom::DemuxerStream> demuxer_stream_;
-  base::Closure stream_ready_cb_;
+  base::OnceClosure stream_ready_cb_;
 
   // The last ReadCB received through a call to Read().
   // Used to store the results of OnBufferReady() in the event it is called

media/mojo/services/mojo_renderer_service.cc

@@ -45,7 +45,7 @@ mojo::SelfOwnedReceiverRef<mojom::Renderer> MojoRendererService::Create(
                                                    std::move(receiver));
 
   service->set_bad_message_cb(
-      base::Bind(&CloseReceiverOnBadMessage, self_owned_receiver));
+      base::BindRepeating(&CloseReceiverOnBadMessage, self_owned_receiver));
 
   return self_owned_receiver;
 }