Update VideoRenderer::Flush to use OnceClosure.

Previously Flush() was taking base::Closure, which is deprecated.
Replaced with base::OnceClosure.

Bug: 751838
Change-Id: Iccd5bb58b262cb67f87810613b180da9148fe145
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1940300
Commit-Queue: Sergey Ulanov <sergeyu@chromium.org>
Auto-Submit: Sergey Ulanov <sergeyu@chromium.org>
Reviewed-by: Xiaohan Wang <xhwang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#719849}

media/base/mock_filters.h

@@ -298,7 +298,7 @@ class MockVideoRenderer : public VideoRenderer {
                     RendererClient* client,
                     const TimeSource::WallClockTimeCB& wall_clock_time_cb,
                     const PipelineStatusCB& init_cb));
-  MOCK_METHOD1(Flush, void(const base::Closure& callback));
+  MOCK_METHOD1(Flush, void(base::OnceClosure flush_cb));
   MOCK_METHOD1(StartPlayingFrom, void(base::TimeDelta));
   MOCK_METHOD0(OnTimeProgressing, void());
   MOCK_METHOD0(OnTimeStopped, void());
@@ -319,8 +319,7 @@ class MockAudioRenderer : public AudioRenderer {
                     RendererClient* client,
                     const PipelineStatusCB& init_cb));
   MOCK_METHOD0(GetTimeSource, TimeSource*());
-  void Flush(base::OnceClosure flush_cb) { OnFlush(flush_cb); }
-  MOCK_METHOD1(OnFlush, void(base::OnceClosure& flush_cb));
+  MOCK_METHOD1(Flush, void(base::OnceClosure flush_cb));
   MOCK_METHOD0(StartPlaying, void());
   MOCK_METHOD1(SetVolume, void(float volume));
 

media/base/video_renderer.h

@@ -49,7 +49,7 @@ class MEDIA_EXPORT VideoRenderer {
   //
   // Clients should expect |buffering_state_cb| to be called with
   // BUFFERING_HAVE_NOTHING while flushing is in progress.
-  virtual void Flush(const base::Closure& callback) = 0;
+  virtual void Flush(base::OnceClosure callback) = 0;
 
   // Starts playback at |timestamp| by reading from |stream| and decoding and
   // rendering video.

media/renderers/renderer_impl.cc

@@ -536,8 +536,8 @@ void RendererImpl::FlushVideoRenderer() {
   if (!video_renderer_ || !video_playing_) {
     OnVideoRendererFlushDone();
   } else {
-    video_renderer_->Flush(base::BindRepeating(
-        &RendererImpl::OnVideoRendererFlushDone, weak_this_));
+    video_renderer_->Flush(
+        base::BindOnce(&RendererImpl::OnVideoRendererFlushDone, weak_this_));
   }
 }
 
@@ -984,7 +984,7 @@ void RendererImpl::OnSelectedVideoTracksChanged(
   }
 
   pending_video_track_change_ = true;
-  video_renderer_->Flush(base::BindRepeating(
+  video_renderer_->Flush(base::BindOnce(
       &RendererImpl::CleanUpTrackChange, weak_this_,
       base::Passed(&fix_stream_cb), &video_ended_, &video_playing_));
 }

media/renderers/renderer_impl_unittest.cc

@@ -34,12 +34,17 @@ using ::testing::StrictMock;
 using ::testing::WithArg;
 using ::testing::WithArgs;
 
-ACTION_TEMPLATE(MoveArg,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_1_VALUE_PARAMS(out)) {
-  *out = std::move(::testing::get<k>(args));
+namespace {
+
+// Helper used to create an action for gmock that moves the argument to the
+// destination specified by |dst|.
+template <typename T>
+testing::Action<void(T arg)> MoveArg(T* dst) {
+  return testing::Action<void(T arg)>([dst](T arg) { *dst = std::move(arg); });
 }
 
+}  // namespace
+
 namespace media {
 
 const int64_t kStartPlayingTimeInMs = 100;
@@ -149,11 +154,12 @@ class RendererImplTest : public ::testing::Test {
     base::RunLoop().RunUntilIdle();
 
     if (start_status == PIPELINE_OK && audio_stream_) {
-      ON_CALL(*audio_renderer_, OnFlush(_))
-          .WillByDefault(DoAll(
-              SetBufferingState(&audio_renderer_client_, BUFFERING_HAVE_NOTHING,
-                                BUFFERING_CHANGE_REASON_UNKNOWN),
-              RunOnceClosure<0>()));
+      ON_CALL(*audio_renderer_, Flush(_))
+          .WillByDefault([this](base::OnceClosure on_done) {
+            audio_renderer_client_->OnBufferingStateChange(
+                BUFFERING_HAVE_NOTHING, BUFFERING_CHANGE_REASON_UNKNOWN);
+            std::move(on_done).Run();
+          });
       ON_CALL(*audio_renderer_, StartPlaying())
           .WillByDefault(SetBufferingState(&audio_renderer_client_,
                                            BUFFERING_HAVE_ENOUGH,
@@ -161,10 +167,11 @@ class RendererImplTest : public ::testing::Test {
     }
     if (start_status == PIPELINE_OK && video_stream_) {
       ON_CALL(*video_renderer_, Flush(_))
-          .WillByDefault(DoAll(
-              SetBufferingState(&video_renderer_client_, BUFFERING_HAVE_NOTHING,
-                                BUFFERING_CHANGE_REASON_UNKNOWN),
-              RunClosure<0>()));
+          .WillByDefault([this](base::OnceClosure on_done) {
+            video_renderer_client_->OnBufferingStateChange(
+                BUFFERING_HAVE_NOTHING, BUFFERING_CHANGE_REASON_UNKNOWN);
+            std::move(on_done).Run();
+          });
       ON_CALL(*video_renderer_, StartPlayingFrom(_))
           .WillByDefault(SetBufferingState(&video_renderer_client_,
                                            BUFFERING_HAVE_ENOUGH,
@@ -265,7 +272,7 @@ class RendererImplTest : public ::testing::Test {
 
   void SetFlushExpectationsForAVRenderers() {
     if (audio_stream_)
-      EXPECT_CALL(*audio_renderer_, OnFlush(_));
+      EXPECT_CALL(*audio_renderer_, Flush(_));
 
     if (video_stream_)
       EXPECT_CALL(*video_renderer_, Flush(_));
@@ -327,7 +334,7 @@ class RendererImplTest : public ::testing::Test {
     EXPECT_CALL(time_source_, CurrentMediaTime());
     EXPECT_CALL(time_source_, CurrentMediaTime());
     EXPECT_CALL(time_source_, StopTicking());
-    EXPECT_CALL(*audio_renderer_, OnFlush(_));
+    EXPECT_CALL(*audio_renderer_, Flush(_));
 
     // Callback into RestartAudioRenderer
     EXPECT_CALL(*audio_renderer_, StartPlaying());
@@ -663,9 +670,11 @@ TEST_F(RendererImplTest, ErrorDuringFlush) {
 
   InSequence s;
   EXPECT_CALL(time_source_, StopTicking());
-  EXPECT_CALL(*audio_renderer_, OnFlush(_))
-      .WillOnce(DoAll(SetError(&audio_renderer_client_, PIPELINE_ERROR_DECODE),
-                      RunOnceClosure<0>()));
+  EXPECT_CALL(*audio_renderer_, Flush(_))
+      .WillOnce([this](base::OnceClosure on_done) {
+        audio_renderer_client_->OnError(PIPELINE_ERROR_DECODE);
+        std::move(on_done).Run();
+      });
   EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_DECODE));
   EXPECT_CALL(callbacks_, OnFlushed());
   renderer_impl_->Flush(base::BindOnce(&CallbackHelper::OnFlushed,
@@ -832,8 +841,8 @@ TEST_F(RendererImplTest, VideoUnderflowWithAudioFlush) {
   // Flush the audio and video renderers, both think they're in an underflow
   // state, but if the video renderer underflow was deferred, RendererImpl would
   // think it still has enough data.
-  EXPECT_CALL(*audio_renderer_, OnFlush(_)).WillOnce(RunOnceClosure<0>());
-  EXPECT_CALL(*video_renderer_, Flush(_)).WillOnce(RunClosure<0>());
+  EXPECT_CALL(*audio_renderer_, Flush(_)).WillOnce(RunOnceClosure<0>());
+  EXPECT_CALL(*video_renderer_, Flush(_)).WillOnce(RunOnceClosure<0>());
   EXPECT_CALL(callbacks_, OnFlushed());
   renderer_impl_->Flush(base::BindOnce(&CallbackHelper::OnFlushed,
                                        base::Unretained(&callbacks_)));
@@ -902,8 +911,8 @@ TEST_F(RendererImplTest, AudioUnderflowDuringAudioTrackChange) {
 
   // Capture the callback from the audio renderer flush.
   base::OnceClosure audio_renderer_flush_cb;
-  EXPECT_CALL(*audio_renderer_, OnFlush(_))
-      .WillOnce(MoveArg<0>(&audio_renderer_flush_cb));
+  EXPECT_CALL(*audio_renderer_, Flush(_))
+      .WillOnce(MoveArg(&audio_renderer_flush_cb));
 
   EXPECT_CALL(time_source_, CurrentMediaTime()).Times(2);
   std::vector<DemuxerStream*> tracks;
@@ -928,12 +937,12 @@ TEST_F(RendererImplTest, VideoUnderflowDuringVideoTrackChange) {
   base::RunLoop loop;
 
   // Capture the callback from the video renderer flush.
-  base::Closure video_renderer_flush_cb;
+  base::OnceClosure video_renderer_flush_cb;
   {
     InSequence track_switch_seq;
     EXPECT_CALL(time_source_, CurrentMediaTime());
     EXPECT_CALL(*video_renderer_, Flush(_))
-        .WillOnce(SaveArg<0>(&video_renderer_flush_cb));
+        .WillOnce(MoveArg(&video_renderer_flush_cb));
     EXPECT_CALL(*video_renderer_, StartPlayingFrom(_));
     EXPECT_CALL(callbacks_,
                 OnBufferingStateChange(BUFFERING_HAVE_ENOUGH,
@@ -944,7 +953,7 @@ TEST_F(RendererImplTest, VideoUnderflowDuringVideoTrackChange) {
 
   video_renderer_client_->OnBufferingStateChange(
       BUFFERING_HAVE_NOTHING, BUFFERING_CHANGE_REASON_UNKNOWN);
-  video_renderer_flush_cb.Run();
+  std::move(video_renderer_flush_cb).Run();
   loop.Run();
 }
 
@@ -956,8 +965,8 @@ TEST_F(RendererImplTest, VideoUnderflowDuringAudioTrackChange) {
 
   // Capture the callback from the audio renderer flush.
   base::OnceClosure audio_renderer_flush_cb;
-  EXPECT_CALL(*audio_renderer_, OnFlush(_))
-      .WillOnce(MoveArg<0>(&audio_renderer_flush_cb));
+  EXPECT_CALL(*audio_renderer_, Flush(_))
+      .WillOnce(MoveArg(&audio_renderer_flush_cb));
 
   EXPECT_CALL(time_source_, CurrentMediaTime()).Times(2);
   EXPECT_CALL(time_source_, StopTicking());
@@ -981,9 +990,9 @@ TEST_F(RendererImplTest, AudioUnderflowDuringVideoTrackChange) {
   EXPECT_CALL(time_source_, CurrentMediaTime());
 
   // Capture the callback from the audio renderer flush.
-  base::Closure video_renderer_flush_cb;
+  base::OnceClosure video_renderer_flush_cb;
   EXPECT_CALL(*video_renderer_, Flush(_))
-      .WillOnce(SaveArg<0>(&video_renderer_flush_cb));
+      .WillOnce(MoveArg(&video_renderer_flush_cb));
 
   renderer_impl_->OnSelectedVideoTracksChanged({}, loop.QuitClosure());
 
@@ -993,7 +1002,7 @@ TEST_F(RendererImplTest, AudioUnderflowDuringVideoTrackChange) {
   audio_renderer_client_->OnBufferingStateChange(
       BUFFERING_HAVE_NOTHING, BUFFERING_CHANGE_REASON_UNKNOWN);
 
-  video_renderer_flush_cb.Run();
+  std::move(video_renderer_flush_cb).Run();
   loop.Run();
 }
 
@@ -1018,8 +1027,8 @@ TEST_F(RendererImplTest, VideoResumedFromUnderflowDuringAudioTrackChange) {
   {
     InSequence track_switch_seq;
     EXPECT_CALL(time_source_, CurrentMediaTime()).Times(2);
-    EXPECT_CALL(*audio_renderer_, OnFlush(_))
-        .WillOnce(MoveArg<0>(&audio_renderer_flush_cb));
+    EXPECT_CALL(*audio_renderer_, Flush(_))
+        .WillOnce(MoveArg(&audio_renderer_flush_cb));
   }
   renderer_impl_->OnEnabledAudioTracksChanged({}, track_change.QuitClosure());
 
@@ -1052,13 +1061,13 @@ TEST_F(RendererImplTest, AudioResumedFromUnderflowDuringVideoTrackChange) {
   underflow_wait.Run();
 
   // Start a track change.
-  base::Closure video_renderer_flush_cb;
+  base::OnceClosure video_renderer_flush_cb;
   base::RunLoop track_change;
   {
     InSequence track_switch_seq;
     EXPECT_CALL(time_source_, CurrentMediaTime());
     EXPECT_CALL(*video_renderer_, Flush(_))
-        .WillOnce(SaveArg<0>(&video_renderer_flush_cb));
+        .WillOnce(MoveArg(&video_renderer_flush_cb));
   }
   renderer_impl_->OnSelectedVideoTracksChanged({}, track_change.QuitClosure());
 
@@ -1071,7 +1080,7 @@ TEST_F(RendererImplTest, AudioResumedFromUnderflowDuringVideoTrackChange) {
 
   // Finish the track change.
   EXPECT_CALL(*video_renderer_, StartPlayingFrom(_));
-  video_renderer_flush_cb.Run();
+  std::move(video_renderer_flush_cb).Run();
   track_change.Run();
 }
 

media/renderers/video_renderer_impl.cc

@@ -147,7 +147,7 @@ VideoRendererImpl::~VideoRendererImpl() {
     StopSink();
 }
 
-void VideoRendererImpl::Flush(const base::Closure& callback) {
+void VideoRendererImpl::Flush(base::OnceClosure callback) {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
@@ -157,7 +157,7 @@ void VideoRendererImpl::Flush(const base::Closure& callback) {
   base::AutoLock auto_lock(lock_);
 
   DCHECK_EQ(state_, kPlaying);
-  flush_cb_ = callback;
+  flush_cb_ = std::move(callback);
   state_ = kFlushing;
 
   if (buffering_state_ != BUFFERING_HAVE_NOTHING) {

media/renderers/video_renderer_impl.h

@@ -66,7 +66,7 @@ class MEDIA_EXPORT VideoRendererImpl
                   RendererClient* client,
                   const TimeSource::WallClockTimeCB& wall_clock_time_cb,
                   const PipelineStatusCB& init_cb) override;
-  void Flush(const base::Closure& callback) override;
+  void Flush(base::OnceClosure callback) override;
   void StartPlayingFrom(base::TimeDelta timestamp) override;
   void OnTimeProgressing() override;
   void OnTimeStopped() override;
@@ -262,7 +262,7 @@ class MEDIA_EXPORT VideoRendererImpl
 
   // Playback operation callbacks.
   PipelineStatusCB init_cb_;
-  base::Closure flush_cb_;
+  base::OnceClosure flush_cb_;
   TimeSource::WallClockTimeCB wall_clock_time_cb_;
 
   base::TimeDelta start_timestamp_;

media/renderers/video_renderer_impl_unittest.cc

@@ -493,9 +493,9 @@ TEST_F(VideoRendererImplTest, FlushCallbackNoLock) {
   EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(0);
   WaitableMessageLoopEvent event;
-  renderer_->Flush(base::BindRepeating(
-      &VideoRendererImplTest_FlushDoneCB, base::Unretained(this),
-      base::Unretained(renderer_.get()), event.GetClosure()));
+  renderer_->Flush(
+      base::BindOnce(&VideoRendererImplTest_FlushDoneCB, base::Unretained(this),
+                     base::Unretained(renderer_.get()), event.GetClosure()));
   event.RunAndWait();
   Destroy();
 }