Fix callers of VideoDecoder::Reset to use BindOnce

Update callers of VideoDecoder::Reset() to ensure they are using a
OnceCallback or BindOnce.

Change-Id: I3560af2fd75dafc1ea1e4cc471b00b1cef2d17e6
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2079781
Commit-Queue: Wan-Teh Chang <wtc@google.com>
Reviewed-by: danakj <danakj@chromium.org>
Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#745636}

media/cdm/library_cdm/clear_key_cdm/cdm_video_decoder.cc

@@ -211,9 +211,9 @@ class VideoDecoderAdapter : public CdmVideoDecoder {
 
     // Reset |video_decoder_| and wait for completion.
     base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
-    video_decoder_->Reset(base::BindRepeating(&VideoDecoderAdapter::OnReset,
-                                              weak_factory_.GetWeakPtr(),
-                                              run_loop.QuitClosure()));
+    video_decoder_->Reset(base::BindOnce(&VideoDecoderAdapter::OnReset,
+                                         weak_factory_.GetWeakPtr(),
+                                         run_loop.QuitClosure()));
     run_loop.Run();
   }
 

media/filters/decoder_stream.cc

@@ -903,8 +903,8 @@ void DecoderStream<StreamType>::ResetDecoder() {
       << state_;
   DCHECK(reset_cb_);
 
-  decoder_->Reset(base::BindRepeating(
-      &DecoderStream<StreamType>::OnDecoderReset, weak_factory_.GetWeakPtr()));
+  decoder_->Reset(base::BindOnce(&DecoderStream<StreamType>::OnDecoderReset,
+                                 weak_factory_.GetWeakPtr()));
 }
 
 template <DemuxerStream::Type StreamType>

media/filters/fake_video_decoder_unittest.cc

@@ -196,8 +196,8 @@ class FakeVideoDecoderTest
 
   void ResetAndExpect(CallbackResult result) {
     is_reset_pending_ = true;
-    decoder_->Reset(base::Bind(&FakeVideoDecoderTest::OnDecoderReset,
-                               base::Unretained(this)));
+    decoder_->Reset(base::BindOnce(&FakeVideoDecoderTest::OnDecoderReset,
+                                   base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
     ExpectResetResult(result);
   }

media/filters/offloading_video_decoder_unittest.cc

@@ -98,11 +98,11 @@ class OffloadingVideoDecoderTest : public testing::Test {
                       base::Unretained(this));
   }
 
-  base::Closure ExpectResetCB() {
+  base::OnceClosure ExpectResetCB() {
     EXPECT_CALL(*this, ResetDone())
         .WillOnce(VerifyOn(task_env_.GetMainThreadTaskRunner()));
-    return base::Bind(&OffloadingVideoDecoderTest::ResetDone,
-                      base::Unretained(this));
+    return base::BindOnce(&OffloadingVideoDecoderTest::ResetDone,
+                          base::Unretained(this));
   }
 
   void TestNoOffloading(const VideoDecoderConfig& config) {

media/gpu/android/media_codec_video_decoder_unittest.cc

@@ -259,7 +259,7 @@ class MediaCodecVideoDecoderTest : public testing::TestWithParam<VideoCodec> {
   // Start and finish a reset.
   void DoReset() {
     bool reset_complete = false;
-    mcvd_->Reset(base::BindRepeating(
+    mcvd_->Reset(base::BindOnce(
         [](bool* reset_complete) { *reset_complete = true; }, &reset_complete));
     base::RunLoop().RunUntilIdle();
     if (!reset_complete) {
@@ -597,7 +597,7 @@ TEST_P(MediaCodecVideoDecoderTest, TransitionToSameSurfaceIsIgnored) {
 TEST_P(MediaCodecVideoDecoderTest,
        ResetBeforeCodecInitializedSucceedsImmediately) {
   InitializeWithTextureOwner_OneDecodePending(TestVideoConfig::Large(codec_));
-  base::MockCallback<base::Closure> reset_cb;
+  base::MockCallback<base::OnceClosure> reset_cb;
   EXPECT_CALL(reset_cb, Run());
   mcvd_->Reset(reset_cb.Get());
   testing::Mock::VerifyAndClearExpectations(&reset_cb);
@@ -635,7 +635,7 @@ TEST_P(MediaCodecVideoDecoderTest, ResetDoesNotFlushAnAlreadyFlushedCodec) {
 
   // The codec is still in the flushed state so Reset() doesn't need to flush.
   EXPECT_CALL(*codec, Flush()).Times(0);
-  base::MockCallback<base::Closure> reset_cb;
+  base::MockCallback<base::OnceClosure> reset_cb;
   EXPECT_CALL(reset_cb, Run());
   mcvd_->Reset(reset_cb.Get());
   testing::Mock::VerifyAndClearExpectations(&decode_cb_);
@@ -651,7 +651,7 @@ TEST_P(MediaCodecVideoDecoderVp8Test, ResetDrainsVP8CodecsBeforeFlushing) {
   // The reset should not complete immediately because the codec needs to be
   // drained.
   EXPECT_CALL(*codec, Flush()).Times(0);
-  base::MockCallback<base::Closure> reset_cb;
+  base::MockCallback<base::OnceClosure> reset_cb;
   EXPECT_CALL(reset_cb, Run()).Times(0);
   mcvd_->Reset(reset_cb.Get());
 
@@ -720,7 +720,7 @@ TEST_P(MediaCodecVideoDecoderVp8Test, ResetDoesNotDrainVp8WithAsyncApi) {
   // The reset should complete immediately because the codec is not VP8 so
   // it doesn't need draining.  We don't expect a call to Flush on the codec
   // since it will be deferred until the first decode after the reset.
-  base::MockCallback<base::Closure> reset_cb;
+  base::MockCallback<base::OnceClosure> reset_cb;
   EXPECT_CALL(reset_cb, Run());
   mcvd_->Reset(reset_cb.Get());
   // The reset should complete before destroying the codec, since TearDown will
@@ -739,7 +739,7 @@ TEST_P(MediaCodecVideoDecoderH264Test, ResetDoesNotDrainNonVp8Codecs) {
   // The reset should complete immediately because the codec is not VP8 so
   // it doesn't need draining.  We don't expect a call to Flush on the codec
   // since it will be deferred until the first decode after the reset.
-  base::MockCallback<base::Closure> reset_cb;
+  base::MockCallback<base::OnceClosure> reset_cb;
   EXPECT_CALL(reset_cb, Run());
   mcvd_->Reset(reset_cb.Get());
   // The reset should complete before destroying the codec, since TearDown will
@@ -756,7 +756,7 @@ TEST_P(MediaCodecVideoDecoderVp8Test, TeardownCompletesPendingReset) {
   codec->AcceptOneInput();
   PumpCodec();
 
-  base::MockCallback<base::Closure> reset_cb;
+  base::MockCallback<base::OnceClosure> reset_cb;
   EXPECT_CALL(reset_cb, Run()).Times(0);
   mcvd_->Reset(reset_cb.Get());
   EXPECT_CALL(reset_cb, Run());

media/gpu/ipc/service/vda_video_decoder_unittest.cc

@@ -297,7 +297,7 @@ class VdaVideoDecoderTest : public testing::TestWithParam<bool> {
   testing::StrictMock<base::MockCallback<VideoDecoder::OutputCB>> output_cb_;
   testing::StrictMock<base::MockCallback<WaitingCB>> waiting_cb_;
   testing::StrictMock<base::MockCallback<VideoDecoder::DecodeCB>> decode_cb_;
-  testing::StrictMock<base::MockCallback<base::RepeatingClosure>> reset_cb_;
+  testing::StrictMock<base::MockCallback<base::OnceClosure>> reset_cb_;
 
   scoped_refptr<FakeCommandBufferHelper> cbh_;
   testing::StrictMock<MockVideoDecodeAccelerator>* vda_;

media/gpu/test/video_player/video_decoder_client.cc

@@ -345,10 +345,10 @@ void VideoDecoderClient::ResetTask() {
   // TODO(dstaessens@) Allow resetting to any point in the stream.
   encoded_data_helper_->Rewind();
 
-  base::RepeatingClosure reset_done_cb = base::BindRepeating(
+  decoder_->Reset(base::BindOnce(
       CallbackThunk<decltype(&VideoDecoderClient::ResetDoneTask)>, weak_this_,
-      decoder_client_thread_.task_runner(), &VideoDecoderClient::ResetDoneTask);
-  decoder_->Reset(reset_done_cb);
+      decoder_client_thread_.task_runner(),
+      &VideoDecoderClient::ResetDoneTask));
   FireEvent(VideoPlayerEvent::kResetting);
 }
 

media/mojo/services/mojo_video_decoder_service.cc

@@ -293,8 +293,8 @@ void MojoVideoDecoderService::OnReaderRead(
 }
 
 void MojoVideoDecoderService::OnReaderFlushed() {
-  decoder_->Reset(base::BindRepeating(&MojoVideoDecoderService::OnDecoderReset,
-                                      weak_this_));
+  decoder_->Reset(
+      base::BindOnce(&MojoVideoDecoderService::OnDecoderReset, weak_this_));
 }
 
 void MojoVideoDecoderService::OnDecoderDecoded(

media/mojo/test/mojo_video_decoder_integration_test.cc

@@ -480,7 +480,7 @@ TEST_F(MojoVideoDecoderIntegrationTest, ResetDuringDecode) {
   ASSERT_TRUE(Initialize());
 
   StrictMock<base::MockCallback<VideoDecoder::DecodeCB>> decode_cb;
-  StrictMock<base::MockCallback<base::Closure>> reset_cb;
+  StrictMock<base::MockCallback<base::OnceClosure>> reset_cb;
 
   EXPECT_CALL(*decoder_, DidGetReleaseMailboxCB()).Times(AtLeast(0));
   EXPECT_CALL(output_cb_, Run(_)).Times(kMaxDecodeRequests);
@@ -508,7 +508,7 @@ TEST_F(MojoVideoDecoderIntegrationTest, ResetDuringDecode_ChunkedWrite) {
 
   VideoFrame::ReleaseMailboxCB release_cb = VideoFrame::ReleaseMailboxCB();
   StrictMock<base::MockCallback<VideoDecoder::DecodeCB>> decode_cb;
-  StrictMock<base::MockCallback<base::Closure>> reset_cb;
+  StrictMock<base::MockCallback<base::OnceClosure>> reset_cb;
 
   EXPECT_CALL(*decoder_, DidGetReleaseMailboxCB()).Times(AtLeast(0));
   EXPECT_CALL(output_cb_, Run(_)).Times(kMaxDecodeRequests);