Clean-up: Remove accelerated subscriber switch for tab/desktop capture.

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 46 matching lines @@
 double FractionFromExpectedFrameRate(base::TimeDelta delta, int frame_rate) {
   DCHECK_GT(frame_rate, 0);
   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,
-                                       bool events_are_reliable)
+VideoCaptureOracle::VideoCaptureOracle(base::TimeDelta min_capture_period)
     : frame_number_(0),
       last_delivered_frame_number_(-1),
       smoothing_sampler_(min_capture_period,
-                         events_are_reliable,
                          kNumRedundantCapturesOfStaticContent),
       content_sampler_(min_capture_period) {
 }
 
 VideoCaptureOracle::~VideoCaptureOracle() {}
 
 bool VideoCaptureOracle::ObserveEventAndDecideCapture(
     Event event,
     const gfx::Rect& damage_rect,
     base::TimeTicks event_time) {
@@ skipping 84 matching lines @@
   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;
 }
 
 SmoothEventSampler::SmoothEventSampler(base::TimeDelta min_capture_period,
-                                       bool events_are_reliable,
                                        int redundant_capture_goal)
-    :  events_are_reliable_(events_are_reliable),
-       min_capture_period_(min_capture_period),
+    :  min_capture_period_(min_capture_period),
        redundant_capture_goal_(redundant_capture_goal),
        token_bucket_capacity_(min_capture_period + min_capture_period / 2),
        overdue_sample_count_(0),
        token_bucket_(token_bucket_capacity_) {
   DCHECK_GT(min_capture_period_.InMicroseconds(), 0);
 }
 
 void SmoothEventSampler::ConsiderPresentationEvent(base::TimeTicks event_time) {
   DCHECK(!event_time.is_null());
 
@@ skipping 33 matching lines @@
     overdue_sample_count_ = 0;
   } else {
     ++overdue_sample_count_;
   }
 }
 
 bool SmoothEventSampler::IsOverdueForSamplingAt(base::TimeTicks event_time)
     const {
   DCHECK(!event_time.is_null());
 
-  // If we don't get events on compositor updates on this platform, then we
-  // don't reliably know whether we're dirty.
-  if (events_are_reliable_) {
-    if (!HasUnrecordedEvent() &&
-        overdue_sample_count_ >= redundant_capture_goal_) {
-      return false;  // Not dirty.
-    }
-  }
+  if (!HasUnrecordedEvent() && overdue_sample_count_ >= redundant_capture_goal_)
+    return false;  // Not dirty.
 
   if (last_sample_.is_null())
     return true;
 
   // If we're dirty but not yet old, then we've recently gotten updates, so we
   // won't request a sample just yet.
   base::TimeDelta dirty_interval = event_time - last_sample_;
   return dirty_interval >=
       base::TimeDelta::FromMilliseconds(kNonAnimatingThresholdMillis);
 }
@@ skipping 176 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