Convert base::Bind and base::Callback in //media/test to Once or Repeating

This CL converts base::Bind to Once or Repeating and base::Callback to
Once or Repeating in //media/test directory.

Bug: 1007812
Change-Id: I482a583dcf004927c84975c6cb1bcf01adf00b53
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2082024Reviewed-by: Xiaohan Wang <xhwang@chromium.org>
Commit-Queue: Jun Cai <juncai@chromium.org>
Cr-Commit-Position: refs/heads/master@{#747834}

media/filters/chunk_demuxer.cc

@@ -446,15 +446,15 @@ void ChunkDemuxerStream::CompletePendingReadIfPossible_Locked() {
 }
 
 ChunkDemuxer::ChunkDemuxer(
-    const base::Closure& open_cb,
-    const base::Closure& progress_cb,
+    base::OnceClosure open_cb,
+    base::RepeatingClosure progress_cb,
     EncryptedMediaInitDataCB encrypted_media_init_data_cb,
     MediaLog* media_log)
     : state_(WAITING_FOR_INIT),
       cancel_next_seek_(false),
       host_(nullptr),
-      open_cb_(open_cb),
-      progress_cb_(progress_cb),
+      open_cb_(std::move(open_cb)),
+      progress_cb_(std::move(progress_cb)),
       encrypted_media_init_data_cb_(std::move(encrypted_media_init_data_cb)),
       media_log_(media_log),
       duration_(kNoTimestamp),

media/filters/chunk_demuxer.h

@@ -205,8 +205,8 @@ class MEDIA_EXPORT ChunkDemuxer : public Demuxer {
   // |encrypted_media_init_data_cb| Run when the demuxer determines that an
   //   encryption key is needed to decrypt the content.
   // |media_log| Used to report content and engine debug messages.
-  ChunkDemuxer(const base::Closure& open_cb,
-               const base::Closure& progress_cb,
+  ChunkDemuxer(base::OnceClosure open_cb,
+               base::RepeatingClosure progress_cb,
                EncryptedMediaInitDataCB encrypted_media_init_data_cb,
                MediaLog* media_log);
   ~ChunkDemuxer() override;
@@ -471,8 +471,8 @@ class MEDIA_EXPORT ChunkDemuxer : public Demuxer {
   bool cancel_next_seek_;
 
   DemuxerHost* host_;
-  base::Closure open_cb_;
-  base::Closure progress_cb_;
+  base::OnceClosure open_cb_;
+  const base::RepeatingClosure progress_cb_;
   EncryptedMediaInitDataCB encrypted_media_init_data_cb_;
 
   // MediaLog for reporting messages and properties to debug content and engine.

media/test/fake_encrypted_media.cc

@@ -23,14 +23,14 @@ int FakeEncryptedMedia::TestCdmContext::GetCdmId() const {
 
 FakeEncryptedMedia::FakeEncryptedMedia(AppBase* app)
     : decryptor_(new AesDecryptor(
-          base::Bind(&FakeEncryptedMedia::OnSessionMessage,
-                     base::Unretained(this)),
-          base::Bind(&FakeEncryptedMedia::OnSessionClosed,
-                     base::Unretained(this)),
-          base::Bind(&FakeEncryptedMedia::OnSessionKeysChange,
-                     base::Unretained(this)),
-          base::Bind(&FakeEncryptedMedia::OnSessionExpirationUpdate,
-                     base::Unretained(this)))),
+          base::BindRepeating(&FakeEncryptedMedia::OnSessionMessage,
+                              base::Unretained(this)),
+          base::BindRepeating(&FakeEncryptedMedia::OnSessionClosed,
+                              base::Unretained(this)),
+          base::BindRepeating(&FakeEncryptedMedia::OnSessionKeysChange,
+                              base::Unretained(this)),
+          base::BindRepeating(&FakeEncryptedMedia::OnSessionExpirationUpdate,
+                              base::Unretained(this)))),
       cdm_context_(decryptor_.get()),
       app_(app) {}
 

media/test/pipeline_integration_fuzzertest.cc

@@ -200,7 +200,7 @@ class MediaSourcePipelineIntegrationFuzzerTest
     source.set_do_eos_after_next_append(true);
 
     source.set_encrypted_media_init_data_cb(
-        base::Bind(&OnEncryptedMediaInitData, this));
+        base::BindRepeating(&OnEncryptedMediaInitData, this));
 
     // Allow parsing to either pass or fail without emitting a gtest failure
     // from TestMediaSource.

media/test/pipeline_integration_test.cc

@@ -230,10 +230,10 @@ class KeyProvidingApp : public FakeEncryptedMedia::AppBase {
   std::unique_ptr<SimpleCdmPromise> CreatePromise(PromiseResult expected) {
     std::unique_ptr<media::SimpleCdmPromise> promise(
         new media::CdmCallbackPromise<>(
-            base::Bind(&KeyProvidingApp::OnResolve, base::Unretained(this),
-                       expected),
-            base::Bind(&KeyProvidingApp::OnReject, base::Unretained(this),
-                       expected)));
+            base::BindOnce(&KeyProvidingApp::OnResolve, base::Unretained(this),
+                           expected),
+            base::BindOnce(&KeyProvidingApp::OnReject, base::Unretained(this),
+                           expected)));
     return promise;
   }
 
@@ -241,10 +241,10 @@ class KeyProvidingApp : public FakeEncryptedMedia::AppBase {
       PromiseResult expected) {
     std::unique_ptr<media::NewSessionCdmPromise> promise(
         new media::CdmCallbackPromise<std::string>(
-            base::Bind(&KeyProvidingApp::OnResolveWithSession,
-                       base::Unretained(this), expected),
-            base::Bind(&KeyProvidingApp::OnReject, base::Unretained(this),
-                       expected)));
+            base::BindOnce(&KeyProvidingApp::OnResolveWithSession,
+                           base::Unretained(this), expected),
+            base::BindOnce(&KeyProvidingApp::OnReject, base::Unretained(this),
+                           expected)));
     return promise;
   }
 
@@ -2126,7 +2126,8 @@ std::vector<std::unique_ptr<VideoDecoder>> CreateFailingVideoDecoder() {
 
 TEST_F(PipelineIntegrationTest, BasicFallback) {
   ASSERT_EQ(PIPELINE_OK,
-            Start("bear.mp4", kNormal, base::Bind(&CreateFailingVideoDecoder)));
+            Start("bear.mp4", kNormal,
+                  base::BindRepeating(&CreateFailingVideoDecoder)));
 
   Play();
 

media/test/pipeline_integration_test_base.cc

@@ -198,7 +198,7 @@ void PipelineIntegrationTestBase::OnSeeked(base::TimeDelta seek_time,
 }
 
 void PipelineIntegrationTestBase::OnStatusCallback(
-    const base::Closure& quit_run_loop_closure,
+    const base::RepeatingClosure& quit_run_loop_closure,
     PipelineStatus status) {
   pipeline_status_ = status;
 
@@ -303,8 +303,9 @@ PipelineStatus PipelineIntegrationTestBase::StartInternal(
   if (cdm_context) {
     EXPECT_CALL(*this, DecryptorAttached(true));
     pipeline_->SetCdm(
-        cdm_context, base::Bind(&PipelineIntegrationTestBase::DecryptorAttached,
-                                base::Unretained(this)));
+        cdm_context,
+        base::BindOnce(&PipelineIntegrationTestBase::DecryptorAttached,
+                       base::Unretained(this)));
   }
 
   // Should never be called as the required decryption keys for the encrypted
@@ -318,9 +319,10 @@ PipelineStatus PipelineIntegrationTestBase::StartInternal(
   EXPECT_CALL(*this, OnVideoConfigChange(_)).Times(AnyNumber());
 
   base::RunLoop run_loop;
-  pipeline_->Start(Pipeline::StartType::kNormal, demuxer_.get(), this,
-                   base::Bind(&PipelineIntegrationTestBase::OnStatusCallback,
-                              base::Unretained(this), run_loop.QuitClosure()));
+  pipeline_->Start(
+      Pipeline::StartType::kNormal, demuxer_.get(), this,
+      base::BindOnce(&PipelineIntegrationTestBase::OnStatusCallback,
+                     base::Unretained(this), run_loop.QuitClosure()));
   RunUntilQuitOrEndedOrError(&run_loop);
   return pipeline_status_;
 }
@@ -387,17 +389,18 @@ bool PipelineIntegrationTestBase::Seek(base::TimeDelta seek_time) {
   // playback may cause any number of underflow/preroll events.
   EXPECT_CALL(*this, OnBufferingStateChange(_, _)).Times(AnyNumber());
 
-  pipeline_->Seek(seek_time, base::Bind(&PipelineIntegrationTestBase::OnSeeked,
-                                        base::Unretained(this), seek_time));
+  pipeline_->Seek(seek_time,
+                  base::BindOnce(&PipelineIntegrationTestBase::OnSeeked,
+                                 base::Unretained(this), seek_time));
   RunUntilQuitOrError(&run_loop);
   return (pipeline_status_ == PIPELINE_OK);
 }
 
 bool PipelineIntegrationTestBase::Suspend() {
   base::RunLoop run_loop;
-  pipeline_->Suspend(base::Bind(&PipelineIntegrationTestBase::OnStatusCallback,
-                                base::Unretained(this),
-                                run_loop.QuitClosure()));
+  pipeline_->Suspend(
+      base::BindOnce(&PipelineIntegrationTestBase::OnStatusCallback,
+                     base::Unretained(this), run_loop.QuitClosure()));
   RunUntilQuitOrError(&run_loop);
   return (pipeline_status_ == PIPELINE_OK);
 }
@@ -409,8 +412,8 @@ bool PipelineIntegrationTestBase::Resume(base::TimeDelta seek_time) {
   EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH, _))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   pipeline_->Resume(seek_time,
-                    base::Bind(&PipelineIntegrationTestBase::OnSeeked,
-                               base::Unretained(this), seek_time));
+                    base::BindOnce(&PipelineIntegrationTestBase::OnSeeked,
+                                   base::Unretained(this), seek_time));
   RunUntilQuitOrError(&run_loop);
   return (pipeline_status_ == PIPELINE_OK);
 }
@@ -471,8 +474,9 @@ void PipelineIntegrationTestBase::CreateDemuxer(
       base::BindRepeating(
           &PipelineIntegrationTestBase::DemuxerEncryptedMediaInitDataCB,
           base::Unretained(this)),
-      base::Bind(&PipelineIntegrationTestBase::DemuxerMediaTracksUpdatedCB,
-                 base::Unretained(this)),
+      base::BindRepeating(
+          &PipelineIntegrationTestBase::DemuxerMediaTracksUpdatedCB,
+          base::Unretained(this)),
       &media_log_, true));
 #endif
 }
@@ -482,15 +486,15 @@ std::unique_ptr<Renderer> PipelineIntegrationTestBase::CreateRenderer(
   // Simulate a 60Hz rendering sink.
   video_sink_.reset(new NullVideoSink(
       clockless_playback_, base::TimeDelta::FromSecondsD(1.0 / 60),
-      base::Bind(&PipelineIntegrationTestBase::OnVideoFramePaint,
-                 base::Unretained(this)),
+      base::BindRepeating(&PipelineIntegrationTestBase::OnVideoFramePaint,
+                          base::Unretained(this)),
       task_environment_.GetMainThreadTaskRunner()));
 
   // Disable frame dropping if hashing is enabled.
   std::unique_ptr<VideoRenderer> video_renderer(new VideoRendererImpl(
       task_environment_.GetMainThreadTaskRunner(), video_sink_.get(),
-      base::Bind(&CreateVideoDecodersForTest, &media_log_,
-                 prepend_video_decoders_cb_),
+      base::BindRepeating(&CreateVideoDecodersForTest, &media_log_,
+                          prepend_video_decoders_cb_),
       false, &media_log_, nullptr));
 
   if (!clockless_playback_) {
@@ -521,9 +525,9 @@ std::unique_ptr<Renderer> PipelineIntegrationTestBase::CreateRenderer(
       (clockless_playback_)
           ? static_cast<AudioRendererSink*>(clockless_audio_sink_.get())
           : audio_sink_.get(),
-      base::Bind(&CreateAudioDecodersForTest, &media_log_,
-                 task_environment_.GetMainThreadTaskRunner(),
-                 prepend_audio_decoders_cb_),
+      base::BindRepeating(&CreateAudioDecodersForTest, &media_log_,
+                          task_environment_.GetMainThreadTaskRunner(),
+                          prepend_audio_decoders_cb_),
       &media_log_));
   if (hashing_enabled_) {
     if (clockless_playback_)
@@ -634,8 +638,8 @@ PipelineStatus PipelineIntegrationTestBase::StartPipelineWithMediaSource(
   base::RunLoop run_loop;
 
   source->set_demuxer_failure_cb(
-      base::Bind(&PipelineIntegrationTestBase::OnStatusCallback,
-                 base::Unretained(this), run_loop.QuitClosure()));
+      base::BindRepeating(&PipelineIntegrationTestBase::OnStatusCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
   demuxer_ = source->GetDemuxer();
 
   // DemuxerStreams may signal config changes.
@@ -652,21 +656,22 @@ PipelineStatus PipelineIntegrationTestBase::StartPipelineWithMediaSource(
     EXPECT_CALL(*this, OnWaiting(WaitingReason::kNoDecryptionKey)).Times(0);
     pipeline_->SetCdm(
         encrypted_media->GetCdmContext(),
-        base::Bind(&PipelineIntegrationTestBase::DecryptorAttached,
-                   base::Unretained(this)));
+        base::BindOnce(&PipelineIntegrationTestBase::DecryptorAttached,
+                       base::Unretained(this)));
   } else {
     // Encrypted content not used, so this is never called.
     EXPECT_CALL(*this, OnWaiting(WaitingReason::kNoDecryptionKey)).Times(0);
   }
 
-  pipeline_->Start(Pipeline::StartType::kNormal, demuxer_.get(), this,
-                   base::Bind(&PipelineIntegrationTestBase::OnStatusCallback,
-                              base::Unretained(this), run_loop.QuitClosure()));
+  pipeline_->Start(
+      Pipeline::StartType::kNormal, demuxer_.get(), this,
+      base::BindOnce(&PipelineIntegrationTestBase::OnStatusCallback,
+                     base::Unretained(this), run_loop.QuitClosure()));
 
   if (encrypted_media) {
     source->set_encrypted_media_init_data_cb(
-        base::Bind(&FakeEncryptedMedia::OnEncryptedMediaInitData,
-                   base::Unretained(encrypted_media)));
+        base::BindRepeating(&FakeEncryptedMedia::OnEncryptedMediaInitData,
+                            base::Unretained(encrypted_media)));
   }
 
   RunUntilQuitOrEndedOrError(&run_loop);

media/test/pipeline_integration_test_base.h

@@ -204,7 +204,7 @@ class PipelineIntegrationTestBase : public Pipeline::Client {
       FakeEncryptedMedia* encrypted_media);
 
   void OnSeeked(base::TimeDelta seek_time, PipelineStatus status);
-  void OnStatusCallback(const base::Closure& quit_run_loop_closure,
+  void OnStatusCallback(const base::RepeatingClosure& quit_run_loop_closure,
                         PipelineStatus status);
   void DemuxerEncryptedMediaInitDataCB(EmeInitDataType type,
                                        const std::vector<uint8_t>& init_data);

media/test/run_all_unittests.cc

@@ -54,5 +54,5 @@ int main(int argc, char** argv) {
 
   return base::LaunchUnitTests(
       argc, argv,
-      base::Bind(&TestSuiteNoAtExit::Run, base::Unretained(&test_suite)));
+      base::BindOnce(&TestSuiteNoAtExit::Run, base::Unretained(&test_suite)));
 }

media/test/test_media_source.cc

@@ -53,7 +53,8 @@ TestMediaSource::TestMediaSource(const std::string& filename,
       initial_sequence_mode_(initial_sequence_mode),
       mimetype_(mimetype),
       chunk_demuxer_(new ChunkDemuxer(
-          base::Bind(&TestMediaSource::DemuxerOpened, base::Unretained(this)),
+          base::BindOnce(&TestMediaSource::DemuxerOpened,
+                         base::Unretained(this)),
           base::DoNothing(),
           base::BindRepeating(&TestMediaSource::OnEncryptedMediaInitData,
                               base::Unretained(this)),
@@ -86,7 +87,8 @@ TestMediaSource::TestMediaSource(scoped_refptr<DecoderBuffer> data,
       initial_sequence_mode_(initial_sequence_mode),
       mimetype_(mimetype),
       chunk_demuxer_(new ChunkDemuxer(
-          base::Bind(&TestMediaSource::DemuxerOpened, base::Unretained(this)),
+          base::BindOnce(&TestMediaSource::DemuxerOpened,
+                         base::Unretained(this)),
           base::DoNothing(),
           base::BindRepeating(&TestMediaSource::OnEncryptedMediaInitData,
                               base::Unretained(this)),
@@ -225,8 +227,8 @@ void TestMediaSource::DemuxerOpenedTask() {
     return;
   }
   chunk_demuxer_->SetTracksWatcher(
-      kSourceId, base::Bind(&TestMediaSource::InitSegmentReceived,
-                            base::Unretained(this)));
+      kSourceId, base::BindRepeating(&TestMediaSource::InitSegmentReceived,
+                                     base::Unretained(this)));
 
   chunk_demuxer_->SetParseWarningCallback(
       kSourceId, base::BindRepeating(&TestMediaSource::OnParseWarningMock,