Use DwmGetCompositionTimingInfo to get vsync info on Windows

base/time_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.
 
 
 // Windows Timer Primer
 //
 // A good article:  http://www.ddj.com/windows/184416651
 // A good mozilla bug:  http://bugzilla.mozilla.org/show_bug.cgi?id=363258
 //
@@ skipping 353 matching lines @@
       return 0;
 
     // The static_cast<long> is needed as a hint to VS 2008 to tell it
     // which version of abs() to use. Other compilers don't seem to
     // need it, including VS 2010, but to keep code identical we use it
     // everywhere.
     // TODO(joi): Remove the hint if/when we no longer support VS 2008.
     return abs(static_cast<long>((UnreliableNow() - ReliableNow()) - skew_));
   }
 
+  TimeDelta FromQPCValue(LONGLONG qpcValue) {
+    return TimeDelta::FromMicroseconds(
+             static_cast<int64>(qpcValue / ticks_per_microsecond_));
+  }
+
  private:
   HighResNowSingleton()
     : ticks_per_microsecond_(0.0),
       skew_(0) {
     InitializeClock();
 
     // On Athlon X2 CPUs (e.g. model 15) QueryPerformanceCounter is
     // unreliable.  Fallback to low-res clock.
     base::CPU cpu;
     if (cpu.vendor_name() == "AuthenticAMD" && cpu.family() == 15)
       DisableHighResClock();
   }
 
   // Synchronize the QPC clock with GetSystemTimeAsFileTime.
   void InitializeClock() {
     LARGE_INTEGER ticks_per_sec = {0};
     if (!QueryPerformanceFrequency(&ticks_per_sec))
       return;  // Broken, we don't guarantee this function works.
-    ticks_per_microsecond_ = static_cast<float>(ticks_per_sec.QuadPart) /
-      static_cast<float>(Time::kMicrosecondsPerSecond);
+    ticks_per_microsecond_ = static_cast<double>(ticks_per_sec.QuadPart) /
+      static_cast<double>(Time::kMicrosecondsPerSecond);
 
     skew_ = UnreliableNow() - ReliableNow();
   }
 
   // Get the number of microseconds since boot in an unreliable fashion.
   int64 UnreliableNow() {
     LARGE_INTEGER now;
     QueryPerformanceCounter(&now);
     return static_cast<int64>(now.QuadPart / ticks_per_microsecond_);
   }
 
   // Get the number of microseconds since boot in a reliable fashion.
   int64 ReliableNow() {
     return RolloverProtectedNow().InMicroseconds();
   }
 
   // Cached clock frequency -> microseconds. This assumes that the clock
   // frequency is faster than one microsecond (which is 1MHz, should be OK).
-  float ticks_per_microsecond_;  // 0 indicates QPF failed and we're broken.
+  double ticks_per_microsecond_;  // 0 indicates QPF failed and we're broken.
   int64 skew_;  // Skew between lo-res and hi-res clocks (for debugging).
 
   friend struct DefaultSingletonTraits<HighResNowSingleton>;
 };
 
 }  // namespace
 
 // static
 TimeTicks::TickFunctionType TimeTicks::SetMockTickFunction(
     TickFunctionType ticker) {
@@ skipping 16 matching lines @@
 TimeTicks TimeTicks::NowFromSystemTraceTime() {
   return HighResNow();
 }
 
 // static
 int64 TimeTicks::GetQPCDriftMicroseconds() {
   return HighResNowSingleton::GetInstance()->GetQPCDriftMicroseconds();
 }
 
 // static
+TimeTicks TimeTicks::FromQPCValue(LONGLONG qpcValue) {
+    return TimeTicks() +
+           HighResNowSingleton::GetInstance()->FromQPCValue(qpcValue);
+}
+
+// static
 bool TimeTicks::IsHighResClockWorking() {
   return HighResNowSingleton::GetInstance()->IsUsingHighResClock();
 }
+
+// TimeDelta ------------------------------------------------------------------
+
+// static
+TimeDelta TimeDelta::FromQPCValue(LONGLONG qpcValue) {
+    return HighResNowSingleton::GetInstance()->FromQPCValue(qpcValue);
+}