Get high resolution frame timebase and interval on compatible systems

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/debug/trace_event.h"
@@ skipping 66 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;
-        // 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.
         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) {
+          // 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.
-        if (timing_info.rateRefresh.uiDenominator > 0 &&
-            timing_info.rateRefresh.uiNumerator > 0) {
+          // Swap the numerator/denominator to convert frequency to period.
           interval = base::TimeDelta::FromMicroseconds(
               timing_info.rateRefresh.uiDenominator *
               base::Time::kMicrosecondsPerSecond /
               timing_info.rateRefresh.uiNumerator);
         }
       }
     }
 
-    // Double check DWM values against per-display refresh rates.
-    // When DWM compositing is active all displays are normalized to the
-    // refresh rate of the primary display, and won't composite any faster.
-    // If the display refresh rate is higher than the DWM reported value we will
-    // favor the DWM value because any additional frames produced will be
-    // discarded by the OS. If the display refresh rate is lower, however, we
-    // can use that to limit the frames we produce more intelligently.
-    // If DWM compositing is not active we will always use the display refresh.
-    HMONITOR monitor = MonitorFromWindow(window_, MONITOR_DEFAULTTONEAREST);
-    MONITORINFOEX monitor_info;
-    monitor_info.cbSize = sizeof(MONITORINFOEX);
-    BOOL result = GetMonitorInfo(monitor, &monitor_info);
-    if (result) {
-      DEVMODE display_info;
-      display_info.dmSize = sizeof(DEVMODE);
-      display_info.dmDriverExtra = 0;
-      result = EnumDisplaySettings(monitor_info.szDevice, ENUM_CURRENT_SETTINGS,
-          &display_info);
-      if (result && display_info.dmDisplayFrequency > 1) {
-        base::TimeDelta display_interval = base::TimeDelta::FromMicroseconds(
-            (1.0 / static_cast<double>(display_info.dmDisplayFrequency)) *
-            base::Time::kMicrosecondsPerSecond);
-
-        if (!dwm_active || display_interval > interval) {
-          interval = display_interval;
+    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.
+      HMONITOR monitor = MonitorFromWindow(window_, MONITOR_DEFAULTTONEAREST);
+      MONITORINFOEX monitor_info;
+      monitor_info.cbSize = sizeof(MONITORINFOEX);
+      BOOL result = GetMonitorInfo(monitor, &monitor_info);
+      if (result) {
+        DEVMODE display_info;
+        display_info.dmSize = sizeof(DEVMODE);
+        display_info.dmDriverExtra = 0;
+        result = EnumDisplaySettings(monitor_info.szDevice,
+            ENUM_CURRENT_SETTINGS, &display_info);
+        if (result && display_info.dmDisplayFrequency > 1) {
+          interval = base::TimeDelta::FromMicroseconds(
+              (1.0 / static_cast<double>(display_info.dmDisplayFrequency)) *
+              base::Time::kMicrosecondsPerSecond);
         }
       }
     }
 
     if (interval.ToInternalValue() != 0) {
       callback.Run(timebase, interval);
     }
   }
 
  private:
@@ skipping 207 matching lines @@
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableD3D11) ||
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kUseWarp))
     return GetDC(NULL);
   return EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE;
 }
 
 }  // namespace gfx