Fix underflow correction occurring during normal rendering.

media/renderers/video_renderer_impl.cc

 // 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.
 
 #include "media/renderers/video_renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 620 matching lines @@
   std::vector<base::TimeTicks> current_time;
   wall_clock_time_cb_.Run(std::vector<base::TimeDelta>(), &current_time);
   return current_time[0];
 }
 
 bool VideoRendererImpl::IsBeforeStartTime(base::TimeDelta timestamp) {
   return timestamp + video_frame_stream_->AverageDuration() < start_timestamp_;
 }
 
 void VideoRendererImpl::RemoveFramesForUnderflowOrBackgroundRendering() {
-  // Nothing to do if we're not underflowing, background rendering, or frame
-  // dropping is disabled (test only).
-  const bool have_nothing = buffering_state_ == BUFFERING_HAVE_NOTHING;
-  if (!was_background_rendering_ && !have_nothing && !drop_frames_)
-    return;
-
-  // If there are no frames to remove, nothing can be done.
-  if (!algorithm_->frames_queued())
+  // Nothing to do if frame dropping is disabled for testing or we have nothing.
+  if (!drop_frames_ || !algorithm_->frames_queued())
     return;
 
   // If we're paused for prerolling (current time is 0), don't expire any
   // frames. It's possible that during preroll |have_nothing| is false while
   // |was_background_rendering_| is true. We differentiate this from actual
   // background rendering by checking if current time is 0.
   const base::TimeTicks current_time = GetCurrentMediaTimeAsWallClockTime();
   if (current_time.is_null())
     return;
 
   // Background rendering updates may not be ticking fast enough to remove
   // expired frames, so provide a boost here by ensuring we don't exit the
   // decoding cycle too early. Dropped frames are not counted in this case.
   if (was_background_rendering_) {
     algorithm_->RemoveExpiredFrames(tick_clock_->NowTicks());
     return;
   }
 
-  // Use the current media wall clock time plus the frame duration since
-  // RemoveExpiredFrames() is expecting the end point of an interval (it will
-  // subtract from the given value). It's important to always call this so
-  // that frame statistics are updated correctly.
-  frames_dropped_ += algorithm_->RemoveExpiredFrames(
-      current_time + algorithm_->average_frame_duration());
-
   // If we've paused for underflow, and still have no effective frames, clear
   // the entire queue.  Note: this may cause slight inaccuracies in the number
   // of dropped frames since the frame may have been rendered before.
   if (!sink_started_ && !algorithm_->effective_frames_queued()) {
     frames_dropped_ += algorithm_->frames_queued();
     algorithm_->Reset(
         VideoRendererAlgorithm::ResetFlag::kPreserveNextFrameEstimates);
     painted_first_frame_ = false;
 
     // It's possible in the background rendering case for us to expire enough
     // frames that we need to transition from HAVE_ENOUGH => HAVE_NOTHING. Just
     // calling this function will check if we need to transition or not.
     if (buffering_state_ == BUFFERING_HAVE_ENOUGH)
       TransitionToHaveNothing_Locked();
+    return;
   }
+
+  // Use the current media wall clock time plus the frame duration since
+  // RemoveExpiredFrames() is expecting the end point of an interval (it will
+  // subtract from the given value). It's important to always call this so
+  // that frame statistics are updated correctly.
+  if (buffering_state_ == BUFFERING_HAVE_NOTHING) {
+    frames_dropped_ += algorithm_->RemoveExpiredFrames(
+        current_time + algorithm_->average_frame_duration());
+    return;
+  }
+
+  // If we reach this point, the normal rendering process will take care of
+  // removing any expired frames.
 }
 
 void VideoRendererImpl::CheckForMetadataChanges(VideoPixelFormat pixel_format,
                                                 const gfx::Size& natural_size) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Notify client of size and opacity changes if this is the first frame
   // or if those have changed from the last frame.
   if (!have_renderered_frames_ || last_frame_natural_size_ != natural_size) {
     last_frame_natural_size_ = natural_size;
@@ skipping 11 matching lines @@
 
 void VideoRendererImpl::AttemptReadAndCheckForMetadataChanges(
     VideoPixelFormat pixel_format,
     const gfx::Size& natural_size) {
   base::AutoLock auto_lock(lock_);
   CheckForMetadataChanges(pixel_format, natural_size);
   AttemptRead_Locked();
 }
 
 }  // namespace media