Adjust VideoRendererAlgorithm for |frame_dropping_disabled_|

media/filters/video_renderer_algorithm.cc

 // Copyright 2015 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/filters/video_renderer_algorithm.h"
 
 #include <algorithm>
 #include <limits>
 
 namespace media {
@@ skipping 667 matching lines @@
   return base::TimeDelta();
 }
 
 void VideoRendererAlgorithm::UpdateEffectiveFramesQueued() {
   if (frame_queue_.empty() || average_frame_duration_.is_zero() ||
       last_deadline_max_.is_null()) {
     effective_frames_queued_ = frame_queue_.size();
     return;
   }
 
+  // Determine the lower bound of the number of effective queues first.
+  // Normally, this is 0.
+  size_t min_frames_queued = 0;
+
+  // If frame dropping is disabled, the lower bound is the number of frames
+  // that were not rendered yet.
+  if (frame_dropping_disabled_) {
+    min_frames_queued = std::count_if(
+        frame_queue_.cbegin(), frame_queue_.cend(),
+        [](const ReadyFrame& frame) { return frame.render_count == 0; });
+  }
+
+  // Next, see if can report more frames as queued.
+  effective_frames_queued_ =
+      std::max(min_frames_queued, CountEffectiveFramesQueued());
+}
+
+size_t VideoRendererAlgorithm::CountEffectiveFramesQueued() const {
   // If we don't have cadence, subtract off any frames which are before
   // the last rendered frame or are past their expected rendering time.
   if (!cadence_estimator_.has_cadence()) {
     size_t expired_frames = 0;
     for (; expired_frames < frame_queue_.size(); ++expired_frames) {
       const ReadyFrame& frame = frame_queue_[expired_frames];
       if (frame.end_time.is_null() || frame.end_time > last_deadline_max_)
         break;
     }
-    effective_frames_queued_ = frame_queue_.size() - expired_frames;
-    return;
+    return frame_queue_.size() - expired_frames;
   }
 
   // Find the first usable frame to start counting from.
   const int start_index = FindBestFrameByCadence(nullptr);
-  if (start_index < 0) {
-    effective_frames_queued_ = 0;
-    return;
-  }
+  if (start_index < 0)
+    return 0;
 
   const base::TimeTicks minimum_start_time =
       last_deadline_max_ - max_acceptable_drift_;
   size_t renderable_frame_count = 0;
   for (size_t i = start_index; i < frame_queue_.size(); ++i) {
     const ReadyFrame& frame = frame_queue_[i];
     if (frame.render_count < frame.ideal_render_count &&
         (frame.end_time.is_null() || frame.end_time > minimum_start_time)) {
       ++renderable_frame_count;
     }
   }
-
-  effective_frames_queued_ = renderable_frame_count;
+  return renderable_frame_count;
 }
 
 }  // namespace media