1 files changed, 40 insertions, 40 deletions

diff --git a/chromium/media/filters/video_renderer_algorithm.cc b/chromium/media/filters/video_renderer_algorithm.cc
index 08a95cbb2bf..0cef397855b 100644
--- a/chromium/media/filters/video_renderer_algorithm.cc
+++ b/chromium/media/filters/video_renderer_algorithm.cc
@@ -243,42 +243,37 @@ size_t VideoRendererAlgorithm::RemoveExpiredFrames(base::TimeTicks deadline) {
   // Even though we may not be able to remove anything due to having only one
   // frame, correct any estimates which may have been set during EnqueueFrame().
   UpdateFrameStatistics();
+  UpdateEffectiveFramesQueued();
 
   // We always leave at least one frame in the queue, so if there's only one
   // frame there's nothing we can expire.
-  if (frame_queue_.size() == 1) {
-    UpdateEffectiveFramesQueued();
+  if (frame_queue_.size() == 1)
     return 0;
-  }
 
   DCHECK_GT(average_frame_duration_, base::TimeDelta());
 
-  // Finds and removes all frames which are too old to be used; I.e., the end of
-  // their render interval is further than |max_acceptable_drift_| from the
-  // given |deadline|.  We also always expire anything inserted before the last
-  // rendered frame.
+  // Expire everything before the first good frame or everything but the last
+  // frame if there is no good frame.
+  const int first_good_frame = FindFirstGoodFrame();
+  const size_t frames_to_expire =
+      first_good_frame < 0 ? frame_queue_.size() - 1 : first_good_frame;
+  if (!frames_to_expire)
+    return 0;
+
   size_t frames_dropped_without_rendering = 0;
-  size_t frames_to_expire = 0;
-  const base::TimeTicks minimum_start_time =
-      deadline - max_acceptable_drift_ - average_frame_duration_;
-  for (; frames_to_expire < frame_queue_.size() - 1; ++frames_to_expire) {
-    const ReadyFrame& frame = frame_queue_[frames_to_expire];
-    if (frame.start_time >= minimum_start_time)
-      break;
-    if (frame.render_count == frame.drop_count)
-      ++frames_dropped_without_rendering;
-  }
+  for (size_t i = 0; i < frames_to_expire; ++i) {
+    const ReadyFrame& frame = frame_queue_[i];
 
-  if (!frames_to_expire) {
-    UpdateEffectiveFramesQueued();
-    return 0;
+    // Don't count frames that are intentionally dropped by cadence as dropped.
+    if (frame.render_count == frame.drop_count &&
+        (!cadence_estimator_.has_cadence() || frame.ideal_render_count)) {
+      ++frames_dropped_without_rendering;
+    }
   }
 
   cadence_frame_counter_ += frames_to_expire;
   frame_queue_.erase(frame_queue_.begin(),
                      frame_queue_.begin() + frames_to_expire);
-
-  UpdateEffectiveFramesQueued();
   return frames_dropped_without_rendering;
 }
 
@@ -759,33 +754,38 @@ void VideoRendererAlgorithm::UpdateEffectiveFramesQueued() {
       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;
+int VideoRendererAlgorithm::FindFirstGoodFrame() const {
+  const auto minimum_start_time =
+      cadence_estimator_.has_cadence()
+          ? last_deadline_max_ - max_acceptable_drift_
+          : last_deadline_max_;
+
+  size_t start_index = 0;
+  for (; start_index < frame_queue_.size(); ++start_index) {
+    const ReadyFrame& frame = frame_queue_[start_index];
+    if ((!cadence_estimator_.has_cadence() ||
+         frame.render_count < frame.ideal_render_count) &&
+        (frame.end_time.is_null() || frame.end_time > minimum_start_time)) {
+      break;
     }
-    return frame_queue_.size() - expired_frames;
   }
 
-  // Find the first usable frame to start counting from.
-  const int start_index = FindBestFrameByCadence();
+  return start_index == frame_queue_.size() ? -1 : start_index;
+}
+
+size_t VideoRendererAlgorithm::CountEffectiveFramesQueued() const {
+  const int start_index = FindFirstGoodFrame();
   if (start_index < 0)
     return 0;
 
-  const base::TimeTicks minimum_start_time =
-      last_deadline_max_ - max_acceptable_drift_;
+  if (!cadence_estimator_.has_cadence())
+    return frame_queue_.size() - start_index;
+
+  // We should ignore zero cadence frames in our effective frame count.
   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)) {
+    if (frame_queue_[i].ideal_render_count)
       ++renderable_frame_count;
-    }
   }
   return renderable_frame_count;
 }