TabCapture: enforce active refresh if there is un-sampled compositor update

media/capture/content/video_capture_oracle.cc

 // Copyright (c) 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/capture/content/video_capture_oracle.h"
 
 #include <algorithm>
 
 #include "base/format_macros.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 83 matching lines @@
 
 }  // anonymous namespace
 
 VideoCaptureOracle::VideoCaptureOracle(
     base::TimeDelta min_capture_period,
     const gfx::Size& max_frame_size,
     media::ResolutionChangePolicy resolution_change_policy,
     bool enable_auto_throttling)
     : auto_throttling_enabled_(enable_auto_throttling),
       next_frame_number_(0),
+      source_is_dirty_(true),
+      last_event_causing_capture_(kPassiveRefreshRequest),
       last_successfully_delivered_frame_number_(-1),
       num_frames_pending_(0),
       smoothing_sampler_(min_capture_period),
       content_sampler_(min_capture_period),
       resolution_chooser_(max_frame_size, resolution_change_policy),
       buffer_pool_utilization_(base::TimeDelta::FromMicroseconds(
           kBufferUtilizationEvaluationMicros)),
       estimated_capable_area_(base::TimeDelta::FromMicroseconds(
           kConsumerCapabilityEvaluationMicros)) {
   VLOG(1) << "Auto-throttling is "
@@ skipping 17 matching lines @@
     base::TimeTicks event_time) {
   DCHECK_GE(event, 0);
   DCHECK_LT(event, kNumEvents);
   if (event_time < last_event_time_[event]) {
     LOG(WARNING) << "Event time is not monotonically non-decreasing.  "
                  << "Deciding not to capture this frame.";
     return false;
   }
   last_event_time_[event] = event_time;
 
+  // If the event indicates a change to the source content, set a flag that will
+  // prevent passive refresh requests until a capture is made.
+  if (event != kActiveRefreshRequest && event != kPassiveRefreshRequest)
+    source_is_dirty_ = true;
+
   bool should_sample = false;
   duration_of_next_frame_ = base::TimeDelta();
   switch (event) {
     case kCompositorUpdate: {
       smoothing_sampler_.ConsiderPresentationEvent(event_time);
       const bool had_proposal = content_sampler_.HasProposal();
       content_sampler_.ConsiderPresentationEvent(damage_rect, event_time);
       if (content_sampler_.HasProposal()) {
         VLOG_IF(1, !had_proposal) << "Content sampler now detects animation.";
         should_sample = content_sampler_.ShouldSample();
         if (should_sample) {
           event_time = content_sampler_.frame_timestamp();
           duration_of_next_frame_ = content_sampler_.sampling_period();
         }
         last_time_animation_was_detected_ = event_time;
       } else {
         VLOG_IF(1, had_proposal) << "Content sampler detects animation ended.";
         should_sample = smoothing_sampler_.ShouldSample();
       }
       break;
     }
 
+    case kPassiveRefreshRequest:
+      if (source_is_dirty_)
+        break;
+    // Intentional flow-through to next case here!
     case kActiveRefreshRequest:
-    case kPassiveRefreshRequest:
     case kMouseCursorUpdate:
       // Only allow non-compositor samplings when content has not recently been
       // animating, and only if there are no samplings currently in progress.
       if (num_frames_pending_ == 0) {
         if (!content_sampler_.HasProposal() ||
             ((event_time - last_time_animation_was_detected_).InMicroseconds() >
              kAnimationHaltPeriodBeforeOtherSamplingMicros)) {
           smoothing_sampler_.ConsiderPresentationEvent(event_time);
           should_sample = smoothing_sampler_.ShouldSample();
         }
       }
       break;
 
     case kNumEvents:
       NOTREACHED();
       break;
   }
 
   if (!should_sample)
     return false;
+  last_event_causing_capture_ = event;
 
   // If the exact duration of the next frame has not been determined, estimate
   // it using the difference between the current and last frame.
   if (duration_of_next_frame_.is_zero()) {
     if (next_frame_number_ > 0) {
       duration_of_next_frame_ =
           event_time - GetFrameTimestamp(next_frame_number_ - 1);
     }
     const base::TimeDelta upper_bound =
         base::TimeDelta::FromMilliseconds(kUpperBoundDurationEstimateMicros);
@@ skipping 19 matching lines @@
   return true;
 }
 
 int VideoCaptureOracle::next_frame_number() const {
   return next_frame_number_;
 }
 
 void VideoCaptureOracle::RecordCapture(double pool_utilization) {
   DCHECK(std::isfinite(pool_utilization) && pool_utilization >= 0.0);
 
+  if (last_event_causing_capture_ != kPassiveRefreshRequest)

[miu, 2017/03/24 21:17:28]

Per discussion, this shouldn't be necessary. So, just:

  source_is_dirty_ = false;

[braveyao, 2017/03/24 23:12:27]

Done.

+    source_is_dirty_ = false;
+
   smoothing_sampler_.RecordSample();
   const base::TimeTicks timestamp = GetFrameTimestamp(next_frame_number_);
   content_sampler_.RecordSample(timestamp);
 
   if (auto_throttling_enabled_) {
     buffer_pool_utilization_.Update(pool_utilization, timestamp);
     AnalyzeAndAdjust(timestamp);
   }
 
   num_frames_pending_++;
@@ skipping 30 matching lines @@
     return false;
   }
 
   if (!IsFrameInRecentHistory(frame_number)) {
     LOG(WARNING) << "Very old capture being ignored: frame #" << frame_number;
     return false;
   }
 
   if (!capture_was_successful) {
     VLOG(2) << "Capture of frame #" << frame_number << " was not successful.";
+    // Since capture of this frame might have been required for capturing an
+    // update to the source content, set the dirty flag.
+    source_is_dirty_ = true;
     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.
@@ skipping 268 matching lines @@
   // Content is not animating, so permit an immediate increase in the capture
   // area.  This allows the system to quickly improve the quality of
   // non-animating content (frame drops are not much of a concern).
   VLOG(2) << "Proposing a "
           << (100.0 * (increased_area - current_area) / current_area)
           << "% increase in capture area for non-animating content.  :-)";
   return increased_area;
 }
 
 }  // namespace media