Plumb vsync info from AcceleratedPresenter to RenderWidgetHostImpl

ui/surface/accelerated_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/surface/accelerated_surface_win.h"
 
 #include <dwmapi.h>
 #include <windows.h>
 #include <algorithm>
 
@@ skipping 414 matching lines @@
 }
 
 scoped_refptr<AcceleratedPresenter> AcceleratedPresenter::GetForWindow(
     gfx::NativeWindow window) {
   return g_accelerated_presenter_map.Pointer()->GetPresenter(window);
 }
 
 void AcceleratedPresenter::AsyncPresentAndAcknowledge(
     const gfx::Size& size,
     int64 surface_handle,
-    const base::Callback<void(bool)>& completion_task) {
+    const CompletionTask& completion_task) {
   if (!surface_handle) {
     TRACE_EVENT1("gpu", "EarlyOut_ZeroSurfaceHandle",
                  "surface_handle", surface_handle);
-    completion_task.Run(true);
+    completion_task.Run(true, base::TimeTicks(), base::TimeDelta());
     return;
   }
 
   present_thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&AcceleratedPresenter::DoPresentAndAcknowledge,
                  this,
                  size,
                  surface_handle,
                  completion_task));
@@ skipping 218 matching lines @@
   if (cmd_line->HasSwitch(switches::kGpuSwapDelay)) {
     base::StringToInt(cmd_line->GetSwitchValueNative(
         switches::kGpuSwapDelay).c_str(), &delay);
   }
   return base::TimeDelta::FromMilliseconds(delay);
 }
 
 void AcceleratedPresenter::DoPresentAndAcknowledge(
     const gfx::Size& size,
     int64 surface_handle,
-    const base::Callback<void(bool)>& completion_task) {
+    const CompletionTask& completion_task) {
   TRACE_EVENT1(
       "gpu", "DoPresentAndAcknowledge", "surface_handle", surface_handle);
 
   HRESULT hr;
 
   base::AutoLock locked(lock_);
 
   // Initialize the device lazily since calling Direct3D can crash bots.
   present_thread_->InitDevice();
 
   if (!present_thread_->device()) {
     if (!completion_task.is_null())
-      completion_task.Run(false);
+      completion_task.Run(false, base::TimeTicks(), base::TimeDelta());
     return;
   }
 
   // Ensure the task is always run and while the lock is taken.
-  base::ScopedClosureRunner scoped_completion_runner(base::Bind(completion_task,
-                                                                true));
+  base::ScopedClosureRunner scoped_completion_runner(
+      base::Bind(completion_task, true, base::TimeTicks(), base::TimeDelta()));
 
   // If invalidated, do nothing, the window is gone.
   if (!window_)
     return;
 
   // If the window is a different size than the swap chain that is being
   // presented then drop the frame.
   RECT window_rect;
   GetClientRect(window_, &window_rect);
   if (hidden_ && (window_rect.right != size.width() ||
@@ skipping 134 matching lines @@
     TRACE_EVENT0("gpu", "Present");
     hr = swap_chain_->Present(&rect, &rect, window_, NULL, 0);
     // For latency_tests.cc:
     UNSHIPPED_TRACE_EVENT_INSTANT0("test_gpu", "CompositorSwapBuffersComplete");
     if (FAILED(hr) &&
         FAILED(present_thread_->device()->CheckDeviceState(window_))) {
       present_thread_->ResetDevice();
     }
   }
 
+  {
+    TRACE_EVENT0("gpu", "GetPresentationStats");
+    base::TimeTicks timebase;
+    base::TimeDelta interval;
+    uint32 numerator = 0, denominator = 0;
+    if (GetPresentationStats(&timebase, &numerator, &denominator) &&
+        numerator > 0 && denominator > 0) {
+      int64 interval_micros =
+          static_cast<int64>(1000000 * numerator) / denominator;
+      interval = base::TimeDelta::FromMicroseconds(interval_micros);
+    }
+    scoped_completion_runner.Release();
+    completion_task.Run(true, timebase, interval);
+    TRACE_EVENT2("gpu", "GetPresentationStats",
+                 "timebase", timebase.ToInternalValue(),
+                 "interval", interval.ToInternalValue());
+  }
+
   hidden_ = false;
 }
 
 void AcceleratedPresenter::DoSuspend() {
   base::AutoLock locked(lock_);
   swap_chain_ = NULL;
 }
 
 void AcceleratedPresenter::DoReleaseSurface() {
   base::AutoLock locked(lock_);
   source_texture_.Release();
 }
 
-void AcceleratedPresenter::GetPresentationStats(base::TimeTicks* timebase,
+bool AcceleratedPresenter::GetPresentationStats(base::TimeTicks* timebase,
                                                 uint32* interval_numerator,
                                                 uint32* interval_denominator) {
   lock_.AssertAcquired();
 
   DWM_TIMING_INFO timing_info;
   timing_info.cbSize = sizeof(timing_info);
   HRESULT result = DwmGetCompositionTimingInfo(window_, &timing_info);
   if (result != S_OK)
-    return;
+    return false;
 
   *timebase = base::TimeTicks::FromQPCValue(
       static_cast<LONGLONG>(timing_info.qpcVBlank));
+  // Offset from QPC-space to TimeTicks::Now-space.
+  *timebase += (base::TimeTicks::Now() - base::TimeTicks::HighResNow());
+
   // Swap the numerator/denominator to convert frequency to period.
   *interval_numerator = timing_info.rateRefresh.uiDenominator;
   *interval_denominator = timing_info.rateRefresh.uiNumerator;
+
+  return true;
 }
 
 AcceleratedSurface::AcceleratedSurface(gfx::NativeWindow window)
     : presenter_(g_accelerated_presenter_map.Pointer()->CreatePresenter(
           window)) {
 }
 
 AcceleratedSurface::~AcceleratedSurface() {
   g_accelerated_presenter_map.Pointer()->RemovePresenter(presenter_);
   presenter_->Invalidate();
 }
 
 bool AcceleratedSurface::Present(HDC dc) {
   return presenter_->Present(dc);
 }
 
 bool AcceleratedSurface::CopyTo(const gfx::Rect& src_subrect,
                                 const gfx::Size& dst_size,
                                 void* buf) {
   return presenter_->CopyTo(src_subrect, dst_size, buf);
 }
 
 void AcceleratedSurface::Suspend() {
   presenter_->Suspend();
 }
 
 void AcceleratedSurface::WasHidden() {
   presenter_->WasHidden();
 }