Fix processing of multiple stream status changes by renderer

media/renderers/renderer_impl.cc

Index: media/renderers/renderer_impl.cc
diff --git a/media/renderers/renderer_impl.cc b/media/renderers/renderer_impl.cc
index 210e5cc574f2437b4368c498f56b02facf5c1e61..eaf950be5417d1d2ca03585d29ea2bf95bfbacfd 100644
--- a/media/renderers/renderer_impl.cc
+++ b/media/renderers/renderer_impl.cc
@@ -32,6 +32,10 @@ static const int kDefaultVideoUnderflowThresholdMs = 3000;
 
 static const int kAudioRestartUnderflowThresholdMs = 2000;
 
+// Specifies the delay for postponed stream status changes while another status
+// change of the same stream type is being handled.
+static const int kStreamStatusHandlingDelayMs = 10;

[xhwang, 2017/01/04 19:34:02]

nit: no need to use "static" here. Namespace scope constant is already static.

[servolk, 2017/01/04 21:29:30]

Done.

+
 class RendererImpl::RendererClientInternal : public RendererClient {
  public:
   RendererClientInternal(DemuxerStream::Type type, RendererImpl* renderer)
@@ -208,28 +212,42 @@ void RendererImpl::StartPlayingFrom(base::TimeDelta time) {
     video_renderer_->StartPlayingFrom(time);
 }
 
-void RendererImpl::RestartStreamPlayback(DemuxerStream* stream,
+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=" << stream->enabled() << " time=" << time.InSecondsF();
+           << " enabled=" << enabled << " time=" << time.InSecondsF();
   if ((state_ != STATE_PLAYING) || (audio_ended_ && video_ended_))
     return;
   if (stream->type() == DemuxerStream::VIDEO) {
     DCHECK(video_renderer_);
-    if (restarting_video_)
+    if (restarting_video_) {
+      DVLOG(3) << __func__ << ": postponed stream " << stream
+               << " status change handling.";
+      task_runner_->PostDelayedTask(
+          FROM_HERE, base::Bind(&RendererImpl::OnStreamStatusChanged,
+                                weak_this_, stream, enabled, time),
+          base::TimeDelta::FromMilliseconds(kStreamStatusHandlingDelayMs));
       return;
+    }
     restarting_video_ = true;
     video_renderer_->Flush(
         base::Bind(&RendererImpl::RestartVideoRenderer, weak_this_, time));
   } else if (stream->type() == DemuxerStream::AUDIO) {
     DCHECK(audio_renderer_);
     DCHECK(time_source_);
-    if (restarting_audio_)
+    if (restarting_audio_) {
+      DVLOG(3) << __func__ << ": postponed stream " << stream
+               << " status change handling.";
+      task_runner_->PostDelayedTask(
+          FROM_HERE, base::Bind(&RendererImpl::OnStreamStatusChanged,
+                                weak_this_, stream, enabled, time),
+          base::TimeDelta::FromMilliseconds(kStreamStatusHandlingDelayMs));
       return;
+    }
     restarting_audio_ = true;
     // Stop ticking (transition into paused state) in audio renderer before
     // calling Flush, since after Flush we are going to restart playback by
@@ -380,7 +398,7 @@ void RendererImpl::InitializeAudioRenderer() {
   }
 
   audio_stream->SetStreamStatusChangeCB(base::Bind(
-      &RendererImpl::RestartStreamPlayback, weak_this_, audio_stream));
+      &RendererImpl::OnStreamStatusChanged, weak_this_, audio_stream));
 
   audio_renderer_client_.reset(
       new RendererClientInternal(DemuxerStream::AUDIO, this));
@@ -429,7 +447,7 @@ void RendererImpl::InitializeVideoRenderer() {
   }
 
   video_stream->SetStreamStatusChangeCB(base::Bind(
-      &RendererImpl::RestartStreamPlayback, weak_this_, video_stream));
+      &RendererImpl::OnStreamStatusChanged, weak_this_, video_stream));
 
   video_renderer_client_.reset(
       new RendererClientInternal(DemuxerStream::VIDEO, this));