Properly handle track status changes in FLUSHED state

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 527 matching lines @@
 }
 
 void RendererImpl::OnStreamStatusChanged(DemuxerStream* stream,
                                          bool enabled,
                                          base::TimeDelta time) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(stream);
   bool video = (stream->type() == DemuxerStream::VIDEO);
   DVLOG(1) << __func__ << (video ? " video" : " audio") << " stream=" << stream
            << " enabled=" << enabled << " time=" << time.InSecondsF();
-  if ((state_ != STATE_PLAYING && state_ != STATE_FLUSHING) ||
+
+  if ((state_ != STATE_PLAYING && state_ != STATE_FLUSHING &&
+       state_ != STATE_FLUSHED) ||
       (audio_ended_ && video_ended_))
     return;
-  if (restarting_audio_ || restarting_video_ || flush_cb_) {
+
+  if (restarting_audio_ || restarting_video_ || state_ == STATE_FLUSHING) {
     DVLOG(3) << __func__ << ": postponed stream " << stream
              << " status change handling.";
     pending_actions_.push_back(base::Bind(&RendererImpl::OnStreamStatusChanged,
                                           weak_this_, stream, enabled, time));
     return;
   }
+
+  DCHECK(state_ == STATE_PLAYING || state_ == STATE_FLUSHED);
   if (stream->type() == DemuxerStream::VIDEO) {
     DCHECK(video_renderer_);
     restarting_video_ = true;
-    video_renderer_->Flush(
+    base::Closure handle_track_status_cb =
         base::Bind(stream == current_video_stream_
                        ? &RendererImpl::RestartVideoRenderer
                        : &RendererImpl::ReinitializeVideoRenderer,
-                   weak_this_, stream, time));
+                   weak_this_, stream, time);
+    if (state_ == STATE_FLUSHED)
+      handle_track_status_cb.Run();
+    else
+      video_renderer_->Flush(handle_track_status_cb);
   } else if (stream->type() == DemuxerStream::AUDIO) {
     DCHECK(audio_renderer_);
     DCHECK(time_source_);
     restarting_audio_ = true;
+    base::Closure handle_track_status_cb =
+        base::Bind(stream == current_audio_stream_
+                       ? &RendererImpl::RestartAudioRenderer
+                       : &RendererImpl::ReinitializeAudioRenderer,
+                   weak_this_, stream, time);
+    if (state_ == STATE_FLUSHED) {
+      handle_track_status_cb.Run();
+      return;
+    }
     // Stop ticking (transition into paused state) in audio renderer before
     // calling Flush, since after Flush we are going to restart playback by
     // calling audio renderer StartPlaying which would fail in playing state.
     if (time_ticking_) {
       time_ticking_ = false;
       time_source_->StopTicking();
     }
-    audio_renderer_->Flush(
-        base::Bind(stream == current_audio_stream_
-                       ? &RendererImpl::RestartAudioRenderer
-                       : &RendererImpl::ReinitializeAudioRenderer,
-                   weak_this_, stream, time));
+    audio_renderer_->Flush(handle_track_status_cb);
   }
 }
 
 void RendererImpl::ReinitializeAudioRenderer(DemuxerStream* stream,
                                              base::TimeDelta time) {
   DVLOG(2) << __func__ << " stream=" << stream << " time=" << time.InSecondsF();
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_NE(stream, current_audio_stream_);
 
   current_audio_stream_ = stream;
@@ skipping 41 matching lines @@
     OnError(status);
     return;
   }
   RestartVideoRenderer(stream, time);
 }
 
 void RendererImpl::RestartAudioRenderer(DemuxerStream* stream,
                                         base::TimeDelta time) {
   DVLOG(2) << __func__ << " stream=" << stream << " time=" << time.InSecondsF();
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(state_ == STATE_PLAYING || state_ == STATE_FLUSHING);
+  DCHECK(state_ == STATE_PLAYING || state_ == STATE_FLUSHED);
   DCHECK(time_source_);
   DCHECK(audio_renderer_);
   DCHECK_EQ(stream, current_audio_stream_);
 
   audio_ended_ = false;
-  audio_renderer_->StartPlaying();
+  if (state_ == STATE_PLAYING)
+    audio_renderer_->StartPlaying();
+  else
+    OnStreamRestartCompleted();
 }
 
 void RendererImpl::RestartVideoRenderer(DemuxerStream* stream,
                                         base::TimeDelta time) {
   DVLOG(2) << __func__ << " stream=" << stream << " time=" << time.InSecondsF();
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(video_renderer_);
-  DCHECK(state_ == STATE_PLAYING || state_ == STATE_FLUSHING);
+  DCHECK(state_ == STATE_PLAYING || state_ == STATE_FLUSHED);
   DCHECK_EQ(stream, current_video_stream_);
 
   video_ended_ = false;
-  video_renderer_->StartPlayingFrom(time);
+  if (state_ == STATE_PLAYING)
+    video_renderer_->StartPlayingFrom(time);
+  else
+    OnStreamRestartCompleted();
 }
 
 void RendererImpl::OnStatisticsUpdate(const PipelineStatistics& stats) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnStatisticsUpdate(stats);
 }
 
 bool RendererImpl::HandleRestartedStreamBufferingChanges(
     DemuxerStream::Type type,
     BufferingState new_buffering_state) {
@@ skipping 56 matching lines @@
           FROM_HERE,
           base::Bind(&RendererImpl::OnStreamRestartCompleted, weak_this_));
     }
   }
   return false;
 }
 
 void RendererImpl::OnStreamRestartCompleted() {
   DVLOG(3) << __func__ << " restarting_audio_=" << restarting_audio_
            << " restarting_video_=" << restarting_video_;
+  DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(restarting_audio_ || restarting_video_);
   restarting_audio_ = false;
   restarting_video_ = false;
   if (!pending_actions_.empty()) {
     base::Closure closure = pending_actions_.front();
     pending_actions_.pop_front();
     closure.Run();
   }
 }
 
@@ skipping 210 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoNaturalSizeChange(size);
 }
 
 void RendererImpl::OnVideoOpacityChange(bool opaque) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoOpacityChange(opaque);
 }
 
 }  // namespace media