Introduce a FLUSHED state in media::RendererImpl

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 224 matching lines @@
           .WillOnce(DoAll(SetBufferingState(&audio_renderer_client_,
                                             BUFFERING_HAVE_NOTHING),
                           RunClosure<0>()));
     }
 
     if (video_stream_) {
       EXPECT_CALL(*video_renderer_, Flush(_))
           .WillOnce(DoAll(SetBufferingState(&video_renderer_client_,
                                             BUFFERING_HAVE_NOTHING),
                           RunClosure<0>()));
     }

[xhwang, 2017/04/06 17:42:55]

Now it's not guaranteed that Flush() will Flush() the audio/video stream, maybe
we should fix the expectation here so that Flush() on audio/video streams are
optional? Or we can store a boolean about 
whether RendererImpl is already flushed... WDYT?

[servolk, 2017/04/06 17:51:31]

Audio/video renderers won't be flushed only when calling Flush immediately after
renderer initialization or after another Flush, without calling StartPlayingFrom
first (that's what the FlushAfterInitialization test does). In all other cases
a/v renderers are guaranteed to be flushed. I believe the
FlushAfterInitialization is a relatively rare corner case, I don't expect
something like that to happen in other tests, so it's probably not worth special
handling here, that's why I've just modified the FlushAfterInitialization to
call RendererImpl::Flush directly, instead of modifying this Flush (and
complicating the logic for the majority of other test cases).

 
     EXPECT_CALL(callbacks_, OnFlushed());
 
     renderer_impl_->Flush(
         base::Bind(&CallbackHelper::OnFlushed, base::Unretained(&callbacks_)));
     base::RunLoop().RunUntilIdle();
   }
 
   void SetPlaybackRate(double playback_rate) {
     EXPECT_CALL(time_source_, SetPlaybackRate(playback_rate));
@@ skipping 229 matching lines @@
   EXPECT_CALL(*video_renderer_, OnTimeStopped());
   SetPlaybackRate(1.0);
   Flush(false);
 
   // A positive playback rate when playback isn't started should do nothing.
   SetPlaybackRate(1.0);
 }
 
 TEST_F(RendererImplTest, FlushAfterInitialization) {
   InitializeWithAudioAndVideo();
-  Flush(true);
+  EXPECT_CALL(callbacks_, OnFlushed());
+  renderer_impl_->Flush(
+      base::Bind(&CallbackHelper::OnFlushed, base::Unretained(&callbacks_)));
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(RendererImplTest, FlushAfterPlay) {
   InitializeWithAudioAndVideo();
   Play();
   Flush(false);
 }
 
 TEST_F(RendererImplTest, FlushAfterUnderflow) {
   InitializeWithAudioAndVideo();
@@ skipping 336 matching lines @@
   // 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();
 }
 
 }  // namespace media