Introduce a FLUSHED state in media::RendererImpl

media/renderers/renderer_impl.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 "media/renderers/renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 166 matching lines @@
   pending_cdm_attached_cb_ = cdm_attached_cb;
 
   InitializeAudioRenderer();
 }
 
 void RendererImpl::Flush(const base::Closure& flush_cb) {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(flush_cb_.is_null());
 
+  if (state_ == STATE_FLUSHED) {
+    task_runner_->PostTask(FROM_HERE, flush_cb);
+    return;
+  }
+
   if (state_ != STATE_PLAYING) {
     DCHECK_EQ(state_, STATE_ERROR);
     return;
   }
 
   flush_cb_ = flush_cb;
   state_ = STATE_FLUSHING;
 
   if (time_ticking_)
     PausePlayback();
 
   FlushAudioRenderer();
 }
 
 void RendererImpl::StartPlayingFrom(base::TimeDelta time) {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  if (state_ != STATE_PLAYING) {
+  if (state_ != STATE_FLUSHED) {
     DCHECK_EQ(state_, STATE_ERROR);
     return;
   }
 
   time_source_->SetMediaTime(time);
 
+  state_ = STATE_PLAYING;
   if (audio_renderer_)
     audio_renderer_->StartPlaying();
   if (video_renderer_)
     video_renderer_->StartPlayingFrom(time);
 }
 
 void RendererImpl::OnStreamStatusChanged(DemuxerStream* stream,
                                          bool enabled,
                                          base::TimeDelta time) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 49 matching lines @@
   DCHECK(audio_renderer_);
   audio_ended_ = false;
   audio_renderer_->StartPlaying();
 }
 
 void RendererImpl::SetPlaybackRate(double playback_rate) {
   DVLOG(1) << __func__ << "(" << playback_rate << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Playback rate changes are only carried out while playing.
-  if (state_ != STATE_PLAYING)
+  if (state_ != STATE_PLAYING && state_ != STATE_FLUSHED)
     return;
 
   time_source_->SetPlaybackRate(playback_rate);
 
   const double old_rate = playback_rate_;
   playback_rate_ = playback_rate;
   if (!time_ticking_ || !video_renderer_)
     return;
 
   if (old_rate == 0 && playback_rate > 0)
@@ skipping 181 matching lines @@
   media_resource_->SetStreamStatusChangeCB(
       base::Bind(&RendererImpl::OnStreamStatusChanged, weak_this_));
 
   if (audio_renderer_) {
     time_source_ = audio_renderer_->GetTimeSource();
   } else if (!time_source_) {
     wall_clock_time_source_.reset(new WallClockTimeSource());
     time_source_ = wall_clock_time_source_.get();
   }
 
-  state_ = STATE_PLAYING;
+  state_ = STATE_FLUSHED;
   DCHECK(time_source_);
   DCHECK(audio_renderer_ || video_renderer_);
 
   FinishInitialization(PIPELINE_OK);
 }
 
 void RendererImpl::FlushAudioRenderer() {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_FLUSHING);
@@ skipping 51 matching lines @@
   if (state_ == STATE_ERROR) {
     DCHECK(flush_cb_.is_null());
     return;
   }
 
   DCHECK_EQ(state_, STATE_FLUSHING);
   DCHECK(!flush_cb_.is_null());
 
   DCHECK_EQ(video_buffering_state_, BUFFERING_HAVE_NOTHING);
   video_ended_ = false;
-  state_ = STATE_PLAYING;
+  state_ = STATE_FLUSHED;
   base::ResetAndReturn(&flush_cb_).Run();
 }
 
 void RendererImpl::OnStatisticsUpdate(const PipelineStatistics& stats) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnStatisticsUpdate(stats);
 }
 
 bool RendererImpl::HandleRestartedStreamBufferingChanges(
     DemuxerStream::Type type,
@@ skipping 160 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   switch (state_) {
     case STATE_PLAYING:
       DCHECK(PlaybackHasEnded() || WaitingForEnoughData() || restarting_audio_)
           << "Playback should only pause due to ending or underflowing or"
              " when restarting audio stream";
 
       break;
 
     case STATE_FLUSHING:
+    case STATE_FLUSHED:
       // It's OK to pause playback when flushing.
       break;
 
     case STATE_UNINITIALIZED:
     case STATE_INIT_PENDING_CDM:
     case STATE_INITIALIZING:
       NOTREACHED() << "Invalid state: " << state_;
       break;
 
     case STATE_ERROR:
@@ skipping 103 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoNaturalSizeChange(size);
 }
 
 void RendererImpl::OnVideoOpacityChange(bool opaque) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoOpacityChange(opaque);
 }
 
 }  // namespace media