Adjust VideoCaptureOracle wrt. out of order captures.

content/browser/media/capture/video_capture_oracle.cc

 // Copyright (c) 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 "content/browser/media/capture/video_capture_oracle.h"
 
 #include <algorithm>
 
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
@@ skipping 20 matching lines @@
   const base::TimeDelta expected_delta =
       base::TimeDelta::FromSeconds(1) / frame_rate;
   return (delta - expected_delta).InMillisecondsF() /
       expected_delta.InMillisecondsF();
 }
 
 }  // anonymous namespace
 
 VideoCaptureOracle::VideoCaptureOracle(base::TimeDelta min_capture_period)
     : next_frame_number_(0),
-      last_delivered_frame_number_(-1),
+      last_successfully_delivered_frame_number_(-1),
+      num_frames_pending_(0),
       smoothing_sampler_(min_capture_period,
                          kNumRedundantCapturesOfStaticContent),
       content_sampler_(min_capture_period) {
 }
 
 VideoCaptureOracle::~VideoCaptureOracle() {}
 
 bool VideoCaptureOracle::ObserveEventAndDecideCapture(
     Event event,
     const gfx::Rect& damage_rect,
@@ skipping 21 matching lines @@
         }
       } else {
         should_sample = smoothing_sampler_.ShouldSample();
         if (should_sample)
           duration_of_next_frame_ = smoothing_sampler_.min_capture_period();
       }
       break;
     case kTimerPoll:
       // While the timer is firing, only allow a sampling if there are none
       // currently in-progress.
-      if (last_delivered_frame_number_ == (next_frame_number_ - 1)) {
+      if (num_frames_pending_ == 0) {
         should_sample = smoothing_sampler_.IsOverdueForSamplingAt(event_time);
         if (should_sample)
           duration_of_next_frame_ = smoothing_sampler_.min_capture_period();
       }
       break;
     case kNumEvents:
       NOTREACHED();
       break;
   }
 
   SetFrameTimestamp(next_frame_number_, event_time);
   return should_sample;
 }
 
 int VideoCaptureOracle::RecordCapture() {
   smoothing_sampler_.RecordSample();
   content_sampler_.RecordSample(GetFrameTimestamp(next_frame_number_));
+  num_frames_pending_++;
   return next_frame_number_++;
 }
 
 bool VideoCaptureOracle::CompleteCapture(int frame_number,
                                          bool capture_was_successful,
                                          base::TimeTicks* frame_timestamp) {
-  // Drop frame if previous frame number is higher.
-  if (last_delivered_frame_number_ > frame_number) {
+  num_frames_pending_--;
+
+  // Drop frame if previously delivered frame number is higher.
+  if (last_successfully_delivered_frame_number_ > frame_number) {
     LOG_IF(WARNING, capture_was_successful)
         << "Out of order frame delivery detected (have #" << frame_number
-        << ", last was #" << last_delivered_frame_number_
+        << ", last was #" << last_successfully_delivered_frame_number_
         << ").  Dropping frame.";
     return false;
   }
-  DCHECK_NE(last_delivered_frame_number_, frame_number);
-  last_delivered_frame_number_ = frame_number;
 
   if (!capture_was_successful) {
     VLOG(2) << "Capture of frame #" << frame_number << " was not successful.";
     return false;
   }
 
+  DCHECK_NE(last_successfully_delivered_frame_number_, frame_number);
+  last_successfully_delivered_frame_number_ = frame_number;
+
   *frame_timestamp = GetFrameTimestamp(frame_number);
 
   // If enabled, log a measurement of how this frame timestamp has incremented
   // in relation to an ideal increment.
   if (VLOG_IS_ON(2) && frame_number > 0) {
     const base::TimeDelta delta =
         *frame_timestamp - GetFrameTimestamp(frame_number - 1);
     if (content_sampler_.HasProposal()) {
       const double estimated_frame_rate =
           1000000.0 / content_sampler_.detected_period().InMicroseconds();
@@ skipping 27 matching lines @@
   DCHECK_LT(next_frame_number_ - frame_number, kMaxFrameTimestamps);
   return frame_timestamps_[frame_number % kMaxFrameTimestamps];
 }
 
 void VideoCaptureOracle::SetFrameTimestamp(int frame_number,
                                            base::TimeTicks timestamp) {
   frame_timestamps_[frame_number % kMaxFrameTimestamps] = timestamp;
 }
 
 }  // namespace content