Fix underflow and av/sync issues in low delay and stall presence.

media/renderers/video_renderer_impl.h

 // Copyright 2013 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_VIDEO_RENDERER_IMPL_H_
 #define MEDIA_RENDERERS_VIDEO_RENDERER_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 61 matching lines @@
                   const PipelineStatusCB& error_cb,
                   const TimeSource::WallClockTimeCB& wall_clock_time_cb,
                   const base::Closure& waiting_for_decryption_key_cb) override;
   void Flush(const base::Closure& callback) override;
   void StartPlayingFrom(base::TimeDelta timestamp) override;
   void OnTimeStateChanged(bool time_progressing) override;
 
   void SetTickClockForTesting(scoped_ptr<base::TickClock> tick_clock);
   void SetGpuMemoryBufferVideoForTesting(
       scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool);
+  size_t frames_queued_for_testing() const {
+    return algorithm_->frames_queued();
+  }
 
   // VideoRendererSink::RenderCallback implementation.
   scoped_refptr<VideoFrame> Render(base::TimeTicks deadline_min,
                                    base::TimeTicks deadline_max,
                                    bool background_rendering) override;
   void OnFrameDropped() override;
 
  private:
   // Callback for |video_frame_stream_| initialization.
   void OnVideoFrameStreamInitialized(bool success);
@@ skipping 56 matching lines @@
 
   // Helper method for converting a single media timestamp to wall clock time.
   base::TimeTicks ConvertMediaTimestamp(base::TimeDelta media_timestamp);
 
   base::TimeTicks GetCurrentMediaTimeAsWallClockTime();
 
   // Helper method for checking if a frame timestamp plus the frame's expected
   // duration is before |start_timestamp_|.
   bool IsBeforeStartTime(base::TimeDelta timestamp);
 
+  // Attempts to remove frames which are no longer effective for rendering when
+  // |buffering_state_| == BUFFERING_HAVE_NOTHING or |was_background_rendering_|
+  // is true.  If the current media time as provided by |wall_clock_time_cb_| is
+  // null, no frame expiration will be done.
+  //
+  // When background rendering the method will expire all frames before the
+  // current wall clock time since it's expected that there will be long delays
+  // between each Render() call in this state.
+  //
+  // When in the underflow state the method will first attempt to remove expired
+  // frames before the current media time plus duration. If |sink_started_| is
+  // true, nothing more can be done. However, if false, and there are still no
+  // effective frames in the queue, the entire frame queue will be released to
+  // avoid any stalling.
+  void RemoveFramesForUnderflowOrBackgroundRendering();
+
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   // Sink which calls into VideoRendererImpl via Render() for video frames.  Do
   // not call any methods on the sink while |lock_| is held or the two threads
   // might deadlock. Do not call Start() or Stop() on the sink directly, use
   // StartSink() and StopSink() to ensure background rendering is started.  Only
   // access these values on |task_runner_|.
   VideoRendererSink* const sink_;
   bool sink_started_;
 
@@ skipping 101 matching lines @@
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<VideoRendererImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoRendererImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_RENDERERS_VIDEO_RENDERER_IMPL_H_