De-dupe copy requests for tab capture in DelegatedFrameHost.

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 49 matching lines @@
       base::TimeDelta::FromSeconds(1) / frame_rate;
   return (delta - expected_delta).InMillisecondsF() /
       expected_delta.InMillisecondsF();
 }
 
 }  // anonymous namespace
 
 VideoCaptureOracle::VideoCaptureOracle(base::TimeDelta min_capture_period)
     : frame_number_(0),
       last_delivered_frame_number_(-1),
+      first_failed_frame_number_(-1),
+      last_failed_frame_number_(-1),
       smoothing_sampler_(min_capture_period,
                          kNumRedundantCapturesOfStaticContent),
       content_sampler_(min_capture_period) {
 }
 
 VideoCaptureOracle::~VideoCaptureOracle() {}
 
 bool VideoCaptureOracle::ObserveEventAndDecideCapture(
     Event event,
     const gfx::Rect& damage_rect,
@@ skipping 33 matching lines @@
 int VideoCaptureOracle::RecordCapture() {
   smoothing_sampler_.RecordSample();
   content_sampler_.RecordSample(GetFrameTimestamp(frame_number_));
   return frame_number_++;
 }
 
 bool VideoCaptureOracle::CompleteCapture(int frame_number,
                                          base::TimeTicks* frame_timestamp) {
   // Drop frame if previous frame number is higher.
   if (last_delivered_frame_number_ > frame_number) {
-    LOG(WARNING) << "Out of order frame delivery detected.  Dropping frame.";
+    LOG(WARNING) << "Out of order frame delivery detected (have #"
+                 << frame_number << ", last was #"
+                 << last_delivered_frame_number_ << ").  Dropping frame.";
     return false;
   }
   last_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 =
@@ skipping 19 matching lines @@
           delta.InMicroseconds(),
           100.0 * FractionFromExpectedFrameRate(delta, 30),
           100.0 * FractionFromExpectedFrameRate(delta, 25),
           100.0 * FractionFromExpectedFrameRate(delta, 24));
     }
   }
 
   return !frame_timestamp->is_null();
 }
 
+void VideoCaptureOracle::CaptureAbortedOrFailed(int frame_number) {
+  VLOG(1) << "Capture aborted/failed for frame #" << frame_number;
+
+  if (frame_number == (last_failed_frame_number_ + 1)) {
+    // Extending consecutive range of failed captures.
+    last_failed_frame_number_ = frame_number;
+  } else {
+    // Starting new consecutive range of failed captures.
+    first_failed_frame_number_ = last_failed_frame_number_ = frame_number;
+  }
+
+  // Account for the case where the newer captures are aborted before an older
+  // capture succeeds.  In this case, the older capture will contain the newest
+  // content and so its timestamp should reflect that.  See
+  // content::DelegatedFrameHost::DidReceiveFrameFromRenderer().
+  const int prior_frame_number = first_failed_frame_number_ - 1;
+  if (prior_frame_number > last_delivered_frame_number_)
+    SetFrameTimestamp(prior_frame_number, GetFrameTimestamp(frame_number));
+}
+
 base::TimeTicks VideoCaptureOracle::GetFrameTimestamp(int frame_number) const {
   DCHECK_LE(frame_number, frame_number_);
   DCHECK_LT(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;
 }
@@ skipping 245 matching lines @@
   if (borrowed_time_ >= min_capture_period_) {
     borrowed_time_ -= min_capture_period_;
     frame_timestamp_ = base::TimeTicks();
   } else {
     sequence_offset_ += advancement;
     frame_timestamp_ = timebase + sequence_offset_;
   }
 }
 
 }  // namespace content