Read compositor VSync information from platform, when possible

ui/gl/sync_control_vsync_provider.cc

 // Copyright 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 "ui/gl/sync_control_vsync_provider.h"
 
 #include <math.h>
 
 #include "base/logging.h"
 #include "base/time/time.h"
 
 #if defined(OS_LINUX)
-// These constants define a reasonable range for a calculated refresh interval.
-// Calculating refreshes out of this range will be considered a fatal error.
-const int64 kMinVsyncIntervalUs = base::Time::kMicrosecondsPerSecond / 400;
-const int64 kMaxVsyncIntervalUs = base::Time::kMicrosecondsPerSecond / 10;
-
 // How much noise we'll tolerate between successive computed intervals before
 // we think the latest computed interval is invalid (noisey due to
 // monitor configuration change, moving a window between monitors, etc.).
 const double kRelativeIntervalDifferenceThreshold = 0.05;
 #endif
 
 namespace gfx {
 
 SyncControlVSyncProvider::SyncControlVSyncProvider()
     : VSyncProvider(), last_media_stream_counter_(0), invalid_msc_(false) {
@@ skipping 87 matching lines @@
       last_computed_intervals_.push(timebase_diff / counter_diff);
   }
 
   if (last_computed_intervals_.size() == 2) {
     const base::TimeDelta& old_interval = last_computed_intervals_.front();
     const base::TimeDelta& new_interval = last_computed_intervals_.back();
 
     double relative_change =
         fabs(old_interval.InMillisecondsF() - new_interval.InMillisecondsF()) /
         new_interval.InMillisecondsF();
-    if (relative_change < kRelativeIntervalDifferenceThreshold) {
-      if (new_interval.InMicroseconds() < kMinVsyncIntervalUs ||
-          new_interval.InMicroseconds() > kMaxVsyncIntervalUs) {
-        LOG(FATAL) << "Calculated bogus refresh interval of "
-                   << new_interval.InMicroseconds() << " us. "
-                   << "Last time base of " << last_timebase_.ToInternalValue()
-                   << " us. "
-                   << "Current time base of " << timebase.ToInternalValue()
-                   << " us. "
-                   << "Last media stream count of "
-                   << last_media_stream_counter_ << ". "
-                   << "Current media stream count of " << media_stream_counter
-                   << ".";
-      } else {
-        last_good_interval_ = new_interval;
-      }
-    }
+    if (relative_change < kRelativeIntervalDifferenceThreshold)
+      last_good_interval_ = new_interval;

[piman, 2014/02/04 04:51:01]

I'd rather we either leave the LOG(FATAL) here, or we remove the logic to
estimate the rate from the intervals altogether.

[sheu, 2014/02/04 22:01:45]

We can't leave the LOG(FATAL) here -- that is the bug we're trying to fix, i.e.
in the case that we get a bogus interval here we can still rely on the interval
queried from the platform display manager (e.g. XRandR).

And we still need to leave the rate estimation in here for platforms that don't
currently run Ash (and for which we have no XRandR hookup).

   }
 
   last_timebase_ = timebase;
   last_media_stream_counter_ = media_stream_counter;
   callback.Run(timebase, last_good_interval_);
 #endif  // defined(OS_LINUX)
 }
 
 }  // namespace gfx