Fix processing of multiple stream status changes by renderer

media/renderers/renderer_impl.h

 // 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.
 
 #ifndef MEDIA_RENDERERS_RENDERER_IMPL_H_
 #define MEDIA_RENDERERS_RENDERER_IMPL_H_
 
+#include <list>
 #include <memory>
 #include <vector>
 
 #include "base/cancelable_callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/time/clock.h"
 #include "base/time/default_tick_clock.h"
@@ skipping 35 matching lines @@
                   RendererClient* client,
                   const PipelineStatusCB& init_cb) final;
   void SetCdm(CdmContext* cdm_context,
               const CdmAttachedCB& cdm_attached_cb) final;
   void Flush(const base::Closure& flush_cb) final;
   void StartPlayingFrom(base::TimeDelta time) final;
   void SetPlaybackRate(double playback_rate) final;
   void SetVolume(float volume) final;
   base::TimeDelta GetMediaTime() final;
 
-  void RestartStreamPlayback(DemuxerStream* stream,
+  void OnStreamStatusChanged(DemuxerStream* stream,
                              bool enabled,
                              base::TimeDelta time);
 
   // Helper functions for testing purposes. Must be called before Initialize().
   void DisableUnderflowForTesting();
   void EnableClocklessVideoPlaybackForTesting();
   void set_time_source_for_testing(TimeSource* time_source) {
     time_source_ = time_source;
   }
   void set_video_underflow_threshold_for_testing(base::TimeDelta threshold) {
@@ skipping 65 matching lines @@
   void OnRendererEnded(DemuxerStream::Type type);
   bool PlaybackHasEnded() const;
   void RunEndedCallbackIfNeeded();
 
   // Callback executed when a runtime error happens.
   void OnError(PipelineStatus error);
   void OnWaitingForDecryptionKey();
   void OnVideoNaturalSizeChange(const gfx::Size& size);
   void OnVideoOpacityChange(bool opaque);
 
+  void OnStreamRestartCompleted();
+
   State state_;
 
   // Task runner used to execute pipeline tasks.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DemuxerStreamProvider* demuxer_stream_provider_;
   RendererClient* client_;
 
   // Temporary callback used for Initialize() and Flush().
   PipelineStatusCB init_cb_;
@@ skipping 31 matching lines @@
 
   // Used to defer underflow for audio when restarting audio playback.
   base::CancelableClosure deferred_audio_restart_underflow_cb_;
 
   // The amount of time to wait before declaring underflow if the video renderer
   // runs out of data but the audio renderer still has enough.
   base::TimeDelta video_underflow_threshold_;
 
   bool restarting_audio_ = false;
   bool restarting_video_ = false;
+  std::list<base::Closure> pending_stream_status_notifications_;
 
   base::WeakPtr<RendererImpl> weak_this_;
   base::WeakPtrFactory<RendererImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_RENDERERS_RENDERER_IMPL_H_