Workaround DwmGetCompositionTimingInfo giving bad qpcRefreshPeriod

ui/gl/gl_surface_win.cc

 // Copyright (c) 2012 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/gl_surface.h"
 
 #include <dwmapi.h>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 58 matching lines @@
     bool dwm_active = false;
 
     // Query the DWM timing info first if available. This will provide the most
     // precise values.
     if (use_dwm_) {
       DWM_TIMING_INFO timing_info;
       timing_info.cbSize = sizeof(timing_info);
       HRESULT result = DwmGetCompositionTimingInfo(NULL, &timing_info);
       if (result == S_OK) {
         dwm_active = true;
+
+        // Calculate a backup interval value using the rateRefresh numerator and
+        // denominator.
+        base::TimeDelta interval2;

[jbauman, 2015/05/14 22:42:39]

Nit, maybe call this "backup_interval".

[brucedawson, 2015/05/14 22:51:57]

How about 'rate_interval'. That gives more of a reminder of where it came from.

[sunnyps, 2015/05/14 23:05:14]

I don't care much about the name but I like low_res_interval or something like
that.

+        if (timing_info.rateRefresh.uiDenominator > 0 &&
+            timing_info.rateRefresh.uiNumerator > 0) {
+          // Swap the numerator/denominator to convert frequency to period.
+          interval2 = base::TimeDelta::FromMicroseconds(
+              timing_info.rateRefresh.uiDenominator *
+              base::Time::kMicrosecondsPerSecond /
+              timing_info.rateRefresh.uiNumerator);
+        }
+
         if (gfx::FrameTime::TimestampsAreHighRes()) {
           // qpcRefreshPeriod is very accurate but noisy, and must be used with
           // a high resolution timebase to avoid frequently missing Vsync.
           timebase = gfx::FrameTime::FromQPCValue(
               static_cast<LONGLONG>(timing_info.qpcVBlank));
           interval = base::TimeDelta::FromQPCValue(
               static_cast<LONGLONG>(timing_info.qpcRefreshPeriod));
-        } else if (timing_info.rateRefresh.uiDenominator > 0 &&
-            timing_info.rateRefresh.uiNumerator > 0) {
+          // Check for interval values that are impossibly low. A 29 microsecond
+          // interval was seen (from a qpcRefreshPeriod of 60).
+          if (interval < base::TimeDelta::FromMilliseconds(1)) {
+            interval = interval2;
+          }
+          // Check for the qpcRefreshPeriod interval being improbably small
+          // compared to the rateRefresh calculated interval, as another
+          // attempt at detecting driver bugs.
+          if (!interval2.is_zero() && interval < interval2 / 2) {
+            interval = interval2;
+          }
+        } else {
           // If FrameTime is not high resolution, we do not want to translate
           // the QPC value provided by DWM into the low-resolution timebase,
           // which would be error prone and jittery. As a fallback, we assume
           // the timebase is zero and use rateRefresh, which may be rounded but
           // isn't noisy like qpcRefreshPeriod, instead. The fact that we don't
           // have a timebase here may lead to brief periods of jank when our
           // scheduling becomes offset from the hardware vsync.
-
-          // Swap the numerator/denominator to convert frequency to period.
-          interval = base::TimeDelta::FromMicroseconds(
-              timing_info.rateRefresh.uiDenominator *
-              base::Time::kMicrosecondsPerSecond /
-              timing_info.rateRefresh.uiNumerator);
+          interval = interval2;
         }
       }
     }
 
     if (!dwm_active) {
       // When DWM compositing is active all displays are normalized to the
       // refresh rate of the primary display, and won't composite any faster.
       // If DWM compositing is disabled, though, we can use the refresh rates
       // reported by each display, which will help systems that have mis-matched
       // displays that run at different frequencies.
@@ skipping 228 matching lines @@
       NOTREACHED();
       return NULL;
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return GetDC(NULL);
 }
 
 }  // namespace gfx