Set Flush/StartPlaying default behavior in RendererImpl unit test

media/renderers/renderer_impl_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 118 matching lines @@
       EXPECT_CALL(*audio_renderer_, GetTimeSource())
           .WillOnce(Return(&time_source_));
     } else {
       renderer_impl_->set_time_source_for_testing(&time_source_);
     }
 
     renderer_impl_->Initialize(demuxer_.get(), &callbacks_,
                                base::Bind(&CallbackHelper::OnInitialize,
                                           base::Unretained(&callbacks_)));
     base::RunLoop().RunUntilIdle();
+
+    if (start_status == PIPELINE_OK && audio_stream_) {
+      ON_CALL(*audio_renderer_, Flush(_))
+          .WillByDefault(DoAll(SetBufferingState(&audio_renderer_client_,
+                                                 BUFFERING_HAVE_NOTHING),
+                               RunClosure<0>()));
+      ON_CALL(*audio_renderer_, StartPlaying())
+          .WillByDefault(SetBufferingState(&audio_renderer_client_,
+                                           BUFFERING_HAVE_ENOUGH));
+    }
+    if (start_status == PIPELINE_OK && video_stream_) {
+      ON_CALL(*video_renderer_, Flush(_))
+          .WillByDefault(DoAll(SetBufferingState(&video_renderer_client_,
+                                                 BUFFERING_HAVE_NOTHING),
+                               RunClosure<0>()));
+      ON_CALL(*video_renderer_, StartPlayingFrom(_))
+          .WillByDefault(SetBufferingState(&video_renderer_client_,
+                                           BUFFERING_HAVE_ENOUGH));
+    }
   }
 
   void CreateAudioStream() {
     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
     streams_.push_back(audio_stream_.get());
     EXPECT_CALL(*demuxer_, GetAllStreams()).WillRepeatedly(Return(streams_));
   }
 
   void CreateVideoStream(bool is_encrypted = false) {
     video_stream_ = CreateStream(DemuxerStream::VIDEO);
@@ skipping 59 matching lines @@
   void Play() {
     DCHECK(audio_stream_ || video_stream_);
     EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
 
     base::TimeDelta start_time(
         base::TimeDelta::FromMilliseconds(kStartPlayingTimeInMs));
     EXPECT_CALL(time_source_, SetMediaTime(start_time));
     EXPECT_CALL(time_source_, StartTicking());
 
     if (audio_stream_) {
-      EXPECT_CALL(*audio_renderer_, StartPlaying())
-          .WillOnce(SetBufferingState(&audio_renderer_client_,
-                                      BUFFERING_HAVE_ENOUGH));
+      EXPECT_CALL(*audio_renderer_, StartPlaying());
     }
 
     if (video_stream_) {
-      EXPECT_CALL(*video_renderer_, StartPlayingFrom(start_time))
-          .WillOnce(SetBufferingState(&video_renderer_client_,
-                                      BUFFERING_HAVE_ENOUGH));
+      EXPECT_CALL(*video_renderer_, StartPlayingFrom(start_time));
     }
 
     renderer_impl_->StartPlayingFrom(start_time);
     base::RunLoop().RunUntilIdle();
   }
 
   void SetFlushExpectationsForAVRenderers() {
-    if (audio_stream_) {
-      EXPECT_CALL(*audio_renderer_, Flush(_))
-          .WillOnce(DoAll(SetBufferingState(&audio_renderer_client_,
-                                            BUFFERING_HAVE_NOTHING),
-                          RunClosure<0>()));
-    }
+    if (audio_stream_)
+      EXPECT_CALL(*audio_renderer_, Flush(_));
 
-    if (video_stream_) {
-      EXPECT_CALL(*video_renderer_, Flush(_))
-          .WillOnce(DoAll(SetBufferingState(&video_renderer_client_,
-                                            BUFFERING_HAVE_NOTHING),
-                          RunClosure<0>()));
-    }
+    if (video_stream_)
+      EXPECT_CALL(*video_renderer_, Flush(_));
   }
 
   void Flush(bool underflowed) {
     if (!underflowed)
       EXPECT_CALL(time_source_, StopTicking());
 
     SetFlushExpectationsForAVRenderers();
     EXPECT_CALL(callbacks_, OnFlushed());
 
     renderer_impl_->Flush(
@@ skipping 487 matching lines @@
   EXPECT_CALL(*video_renderer_, Flush(_)).WillOnce(RunClosure<0>());
   EXPECT_CALL(callbacks_, OnFlushed());
   renderer_impl_->Flush(
       base::Bind(&CallbackHelper::OnFlushed, base::Unretained(&callbacks_)));
   base::RunLoop().RunUntilIdle();
 
   // Start playback after the flush, but never return BUFFERING_HAVE_ENOUGH from
   // the video renderer (which simulates spool up time for the video renderer).
   const base::TimeDelta kStartTime;
   EXPECT_CALL(time_source_, SetMediaTime(kStartTime));
-  EXPECT_CALL(*audio_renderer_, StartPlaying())
-      .WillOnce(
-          SetBufferingState(&audio_renderer_client_, BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(time_source_, StartTicking());
+  EXPECT_CALL(*audio_renderer_, StartPlaying());
   EXPECT_CALL(*video_renderer_, StartPlayingFrom(kStartTime));
+  EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   renderer_impl_->StartPlayingFrom(kStartTime);
 
   // Nothing else should primed on the message loop.
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(RendererImplTest, StreamStatusNotificationHandling) {
   CreateAudioAndVideoStream();
 
   StreamStatusChangeCB stream_status_change_cb;
   EXPECT_CALL(*demuxer_, SetStreamStatusChangeCB(_))
       .WillOnce(SaveArg<0>(&stream_status_change_cb));
   SetAudioRendererInitializeExpectations(PIPELINE_OK);
   SetVideoRendererInitializeExpectations(PIPELINE_OK);
   InitializeAndExpect(PIPELINE_OK);
   Play();
 
+  EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
+
   // Verify that DemuxerStream status changes cause the corresponding
   // audio/video renderer to be flushed and restarted.
   EXPECT_CALL(time_source_, StopTicking());
-  EXPECT_CALL(*audio_renderer_, Flush(_)).WillOnce(RunClosure<0>());
-  EXPECT_CALL(*audio_renderer_, StartPlaying())
-      .Times(1)
-      .WillOnce(
-          SetBufferingState(&audio_renderer_client_, BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(*audio_renderer_, Flush(_));
+  EXPECT_CALL(*audio_renderer_, StartPlaying());
+  EXPECT_CALL(time_source_, StartTicking());
   stream_status_change_cb.Run(audio_stream_.get(), false, base::TimeDelta());
 
-  EXPECT_CALL(*video_renderer_, Flush(_)).WillOnce(RunClosure<0>());
-  EXPECT_CALL(*video_renderer_, StartPlayingFrom(_))
-      .Times(1)
-      .WillOnce(DoAll(
-          SetBufferingState(&video_renderer_client_, BUFFERING_HAVE_ENOUGH),
-          PostQuitWhenIdle()));
-
+  EXPECT_CALL(*video_renderer_, Flush(_));
+  EXPECT_CALL(*video_renderer_, StartPlayingFrom(_));
   stream_status_change_cb.Run(video_stream_.get(), false, base::TimeDelta());
-  base::RunLoop().Run();
+  base::RunLoop().RunUntilIdle();
 }
 
 // Stream status changes are handled asynchronously by the renderer and may take
 // some time to process. This test verifies that all status changes are
 // processed correctly by the renderer even if status changes of the stream
 // happen much faster than the renderer can process them. In that case the
 // renderer may postpone processing status changes, but still must process all
 // of them eventually.
 TEST_F(RendererImplTest, PostponedStreamStatusNotificationHandling) {
   CreateAudioAndVideoStream();
 
   StreamStatusChangeCB stream_status_change_cb;
   EXPECT_CALL(*demuxer_, SetStreamStatusChangeCB(_))
       .WillOnce(SaveArg<0>(&stream_status_change_cb));
   SetAudioRendererInitializeExpectations(PIPELINE_OK);
   SetVideoRendererInitializeExpectations(PIPELINE_OK);
   InitializeAndExpect(PIPELINE_OK);
   Play();
 
   EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .Times(2);
 
   EXPECT_CALL(time_source_, StopTicking()).Times(2);
   EXPECT_CALL(time_source_, StartTicking()).Times(2);
-  EXPECT_CALL(*audio_renderer_, Flush(_))
-      .Times(2)
-      .WillRepeatedly(DoAll(
-          SetBufferingState(&audio_renderer_client_, BUFFERING_HAVE_NOTHING),
-          WithArg<0>(PostCallback())));
-  EXPECT_CALL(*audio_renderer_, StartPlaying())
-      .Times(2)
-      .WillOnce(
-          SetBufferingState(&audio_renderer_client_, BUFFERING_HAVE_ENOUGH))
-      .WillOnce(DoAll(
-          SetBufferingState(&audio_renderer_client_, BUFFERING_HAVE_ENOUGH),
-          PostQuitWhenIdle()));
+  EXPECT_CALL(*audio_renderer_, Flush(_)).Times(2);
+  EXPECT_CALL(*audio_renderer_, StartPlaying()).Times(2);
   // The first stream status change will be processed immediately. Each status
   // change processing involves Flush + StartPlaying when the Flush is done. The
   // Flush operation is async in this case, so the second status change will be
   // postponed by renderer until after processing the first one is finished. But
   // we must still get two pairs of Flush/StartPlaying calls eventually.
   stream_status_change_cb.Run(audio_stream_.get(), false, base::TimeDelta());
   stream_status_change_cb.Run(audio_stream_.get(), true, base::TimeDelta());
-  base::RunLoop().Run();
+  base::RunLoop().RunUntilIdle();
 
-  EXPECT_CALL(*video_renderer_, Flush(_))
-      .Times(2)
-      .WillRepeatedly(DoAll(
-          SetBufferingState(&video_renderer_client_, BUFFERING_HAVE_NOTHING),
-          WithArg<0>(PostCallback())));
-  EXPECT_CALL(*video_renderer_, StartPlayingFrom(base::TimeDelta()))
-      .Times(2)
-      .WillOnce(
-          SetBufferingState(&video_renderer_client_, BUFFERING_HAVE_ENOUGH))
-      .WillOnce(DoAll(
-          SetBufferingState(&video_renderer_client_, BUFFERING_HAVE_ENOUGH),
-          PostQuitWhenIdle()));
+  EXPECT_CALL(*video_renderer_, Flush(_)).Times(2);
+  EXPECT_CALL(*video_renderer_, StartPlayingFrom(base::TimeDelta())).Times(2);
   // The first stream status change will be processed immediately. Each status
   // change processing involves Flush + StartPlaying when the Flush is done. The
   // Flush operation is async in this case, so the second status change will be
   // postponed by renderer until after processing the first one is finished. But
   // we must still get two pairs of Flush/StartPlaying calls eventually.
   stream_status_change_cb.Run(video_stream_.get(), false, base::TimeDelta());
   stream_status_change_cb.Run(video_stream_.get(), true, base::TimeDelta());
-  base::RunLoop().Run();
+  base::RunLoop().RunUntilIdle();
 }
 
 // Verify that a RendererImpl::Flush gets postponed until after stream status
 // change handling is completed.
 TEST_F(RendererImplTest, FlushDuringAudioReinit) {
   CreateAudioAndVideoStream();
 
   StreamStatusChangeCB stream_status_change_cb;
   EXPECT_CALL(*demuxer_, SetStreamStatusChangeCB(_))
       .WillOnce(SaveArg<0>(&stream_status_change_cb));
   SetAudioRendererInitializeExpectations(PIPELINE_OK);
   SetVideoRendererInitializeExpectations(PIPELINE_OK);
   InitializeAndExpect(PIPELINE_OK);
   Play();
 
   EXPECT_CALL(time_source_, StopTicking()).Times(testing::AnyNumber());
   base::Closure audio_renderer_flush_cb;
   EXPECT_CALL(*audio_renderer_, Flush(_))
       .WillOnce(SaveArg<0>(&audio_renderer_flush_cb));
-  EXPECT_CALL(*audio_renderer_, StartPlaying())
-      .Times(1)
-      .WillOnce(
-          SetBufferingState(&audio_renderer_client_, BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(*audio_renderer_, StartPlaying());
 
   // This should start flushing the audio renderer (due to audio stream status
   // change) and should populate the |audio_renderer_flush_cb|.
   stream_status_change_cb.Run(audio_stream_.get(), false, base::TimeDelta());
   EXPECT_TRUE(audio_renderer_flush_cb);
   base::RunLoop().RunUntilIdle();
 
   bool flush_done = false;
 
   // Now that audio stream change is being handled the RendererImpl::Flush
@@ skipping 20 matching lines @@
       .WillOnce(SaveArg<0>(&stream_status_change_cb));
   SetAudioRendererInitializeExpectations(PIPELINE_OK);
   SetVideoRendererInitializeExpectations(PIPELINE_OK);
   InitializeAndExpect(PIPELINE_OK);
   Play();
 
   EXPECT_CALL(time_source_, StopTicking()).Times(testing::AnyNumber());
   base::Closure video_renderer_flush_cb;
   EXPECT_CALL(*video_renderer_, Flush(_))
       .WillOnce(SaveArg<0>(&video_renderer_flush_cb));
-  EXPECT_CALL(*video_renderer_, StartPlayingFrom(_))
-      .Times(1)
-      .WillOnce(
-          SetBufferingState(&video_renderer_client_, BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(*video_renderer_, StartPlayingFrom(_));
 
   // This should start flushing the video renderer (due to video stream status
   // change) and should populate the |video_renderer_flush_cb|.
   stream_status_change_cb.Run(video_stream_.get(), false, base::TimeDelta());
   EXPECT_TRUE(video_renderer_flush_cb);
   base::RunLoop().RunUntilIdle();
 
   bool flush_done = false;
 
   // Now that video stream change is being handled the RendererImpl::Flush
@@ skipping 24 matching lines @@
 
   StreamStatusChangeCB stream_status_change_cb;
   EXPECT_CALL(*demuxer_, SetStreamStatusChangeCB(_))
       .WillOnce(SaveArg<0>(&stream_status_change_cb));
   SetAudioRendererInitializeExpectations(PIPELINE_OK);
   SetVideoRendererInitializeExpectations(PIPELINE_OK);
   InitializeAndExpect(PIPELINE_OK);
   Play();
 
   EXPECT_CALL(time_source_, StopTicking()).Times(testing::AnyNumber());
-  EXPECT_CALL(*video_renderer_, Flush(_))
-      .WillRepeatedly(DoAll(
-          SetBufferingState(&video_renderer_client_, BUFFERING_HAVE_NOTHING),
-          RunClosure<0>()));
+  EXPECT_CALL(*video_renderer_, Flush(_));
 
   // Initiate RendererImpl::Flush, but postpone its completion by not calling
   // audio renderer flush callback right away, i.e. pretending audio renderer
   // flush takes a while.
   base::Closure audio_renderer_flush_cb;
   EXPECT_CALL(*audio_renderer_, Flush(_))
       .WillOnce(SaveArg<0>(&audio_renderer_flush_cb));
   EXPECT_CALL(callbacks_, OnFlushed());
   renderer_impl_->Flush(
       base::Bind(&CallbackHelper::OnFlushed, base::Unretained(&callbacks_)));
@@ skipping 34 matching lines @@
   StreamStatusChangeCB stream_status_change_cb;
   EXPECT_CALL(*demuxer_, SetStreamStatusChangeCB(_))
       .WillOnce(SaveArg<0>(&stream_status_change_cb));
   SetAudioRendererInitializeExpectations(PIPELINE_OK);
   SetVideoRendererInitializeExpectations(PIPELINE_OK);
   InitializeAndExpect(PIPELINE_OK);
   Play();
 
   EXPECT_CALL(time_source_, StopTicking()).Times(testing::AnyNumber());
   EXPECT_CALL(*video_renderer_, OnTimeStopped()).Times(testing::AnyNumber());
-  EXPECT_CALL(*audio_renderer_, Flush(_))
-      .WillRepeatedly(DoAll(
-          SetBufferingState(&audio_renderer_client_, BUFFERING_HAVE_NOTHING),
-          RunClosure<0>()));
+  EXPECT_CALL(*audio_renderer_, Flush(_));
 
   // Initiate RendererImpl::Flush, but postpone its completion by not calling
   // video renderer flush callback right away, i.e. pretending video renderer
   // flush takes a while.
   base::Closure video_renderer_flush_cb;
   EXPECT_CALL(*video_renderer_, Flush(_))
       .WillOnce(SaveArg<0>(&video_renderer_flush_cb));
   EXPECT_CALL(callbacks_, OnFlushed());
   renderer_impl_->Flush(
       base::Bind(&CallbackHelper::OnFlushed, base::Unretained(&callbacks_)));
@@ skipping 15 matching lines @@
   // Complete the video renderer flush, thus completing the renderer_impl_ Flush
   // initiated above. This will transition the RendererImpl into the FLUSHED
   // state and will process pending track switch, which should result in the
   // reinitialization of the video renderer for the secondary video stream.
   video_renderer_client_->OnBufferingStateChange(BUFFERING_HAVE_NOTHING);
   video_renderer_flush_cb.Run();
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace media