SyncControlVSyncProvider: throttle messages when MSC=0

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) {
+    : VSyncProvider(), last_media_stream_counter_(0), invalid_msc_(false) {
   // On platforms where we can't get an accurate reading on the refresh
   // rate we fall back to the assumption that we're displaying 60 frames
   // per second.
   last_good_interval_ = base::TimeDelta::FromSeconds(1) / 60;
 }
 
 SyncControlVSyncProvider::~SyncControlVSyncProvider() {}
 
 void SyncControlVSyncProvider::GetVSyncParameters(
     const UpdateVSyncCallback& callback) {
 #if defined(OS_LINUX)
   base::TimeTicks timebase;
 
   // The actual clock used for the system time returned by glXGetSyncValuesOML
   // is unspecified. In practice, the clock used is likely to be either
   // CLOCK_REALTIME or CLOCK_MONOTONIC, so we compare the returned time to the
   // current time according to both clocks, and assume that the returned time
   // was produced by the clock whose current time is closest to it, subject
   // to the restriction that the returned time must not be in the future
   // (since it is the time of a vblank that has already occurred).
   int64 system_time;
   int64 media_stream_counter;
   int64 swap_buffer_counter;
   if (!GetSyncValues(&system_time, &media_stream_counter, &swap_buffer_counter))
     return;
 
   // Both Intel and Mali drivers will return TRUE for GetSyncValues
   // but a value of 0 for MSC if they cannot access the CRTC data structure
   // associated with the surface. crbug.com/231945
-  if (media_stream_counter == 0) {
-    LOG(ERROR) << "glXGetSyncValuesOML should not return TRUE with a "
-               << "media stream counter of 0.";
+  bool prev_invalid_msc = invalid_msc_;
+  invalid_msc_ = (media_stream_counter == 0);
+  if (invalid_msc_) {
+    LOG_IF(ERROR, !prev_invalid_msc) << "glXGetSyncValuesOML "
+        "should not return TRUE with a media stream counter of 0.";
     return;
   }
 
   struct timespec real_time;
   struct timespec monotonic_time;
   clock_gettime(CLOCK_REALTIME, &real_time);
   clock_gettime(CLOCK_MONOTONIC, &monotonic_time);
 
   int64 real_time_in_microseconds =
       real_time.tv_sec * base::Time::kMicrosecondsPerSecond +
@@ skipping 69 matching lines @@
     }
   }
 
   last_timebase_ = timebase;
   last_media_stream_counter_ = media_stream_counter;
   callback.Run(timebase, last_good_interval_);
 #endif  // defined(OS_LINUX)
 }
 
 }  // namespace gfx