Report accelerated surface vsync time info to browser compositor.

content/browser/gpu/gpu_process_host.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 "content/browser/gpu/gpu_process_host.h"
 
 #include "base/base64.h"
 #include "base/base_switches.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 62 matching lines @@
                            CauseForGpuLaunch cause,
                            IPC::Message* message) {
   GpuProcessHost* host = GpuProcessHost::Get(kind, cause);
   if (host) {
     host->Send(message);
   } else {
     delete message;
   }
 }
 
-void AcceleratedSurfaceBuffersSwappedCompletedForGPU(int host_id,
-                                                     int route_id,
-                                                     bool alive) {
+void AcceleratedSurfaceBuffersSwappedCompletedForGPU(
+    int host_id,
+    int route_id,
+    bool alive,
+    base::TimeTicks vsync_timebase,
+    base::TimeDelta vsync_interval) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&AcceleratedSurfaceBuffersSwappedCompletedForGPU,
                    host_id,
                    route_id,
-                   alive));
+                   alive,
+                   vsync_timebase,
+                   vsync_interval));
     return;
   }
 
   GpuProcessHost* host = GpuProcessHost::FromID(host_id);
   if (host) {
     if (alive) {
       AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
       ack_params.sync_point = 0;
+#if defined(OS_WIN)
+      ack_params.vsync_timebase = vsync_timebase;
+      ack_params.vsync_interval = vsync_interval;
+#endif
       host->Send(
           new AcceleratedSurfaceMsg_BufferPresented(route_id, ack_params));
     } else {
       host->ForceShutdown();
     }
   }
 }
 
 #if defined(OS_WIN)
 // This sends a ViewMsg_SwapBuffers_ACK directly to the renderer process
@@ skipping 31 matching lines @@
 }
 
 void AcceleratedSurfaceBuffersSwappedCompleted(
     int host_id,
     int route_id,
     int surface_id,
     bool alive,
     base::TimeTicks timebase,
     base::TimeDelta interval,
     const ui::LatencyInfo& latency_info) {
-  AcceleratedSurfaceBuffersSwappedCompletedForGPU(host_id, route_id,
-                                                  alive);
-  AcceleratedSurfaceBuffersSwappedCompletedForRenderer(surface_id, timebase,
-                                                       interval, latency_info);
+  AcceleratedSurfaceBuffersSwappedCompletedForGPU(
+      host_id, route_id, alive, timebase, interval);
+  AcceleratedSurfaceBuffersSwappedCompletedForRenderer(
+      surface_id, timebase, interval, latency_info);
 }
 
 // NOTE: changes to this class need to be reviewed by the security team.
 class GpuSandboxedProcessLauncherDelegate
     : public SandboxedProcessLauncherDelegate {
  public:
   explicit GpuSandboxedProcessLauncherDelegate(CommandLine* cmd_line)
       : cmd_line_(cmd_line) {}
   virtual ~GpuSandboxedProcessLauncherDelegate() {}
 
@@ skipping 708 matching lines @@
   // plugin windows.
   if (surface_handle.handle != gfx::kNullPluginWindow ||
       surface_handle.transport_type == gfx::TEXTURE_TRANSPORT) {
     RouteOnUIThread(GpuHostMsg_AcceleratedSurfaceBuffersSwapped(params));
     return;
   }
 
   base::ScopedClosureRunner scoped_completion_runner(
       base::Bind(&AcceleratedSurfaceBuffersSwappedCompletedForGPU,
                  host_id_, params.route_id,
-                 true /* alive */));
+                 true /* alive */, base::TimeTicks(), base::TimeDelta()));
 
   int render_process_id = 0;
   int render_widget_id = 0;
   if (!GpuSurfaceTracker::Get()->GetRenderWidgetIDForSurface(
       params.surface_id, &render_process_id, &render_widget_id)) {
     return;
   }
   RenderWidgetHelper* helper =
       RenderWidgetHelper::FromProcessHostID(render_process_id);
   if (!helper)
@@ skipping 345 matching lines @@
   TRACE_EVENT0("gpu", "GpuProcessHost::OnCacheShader");
   ClientIdToShaderCacheMap::iterator iter =
       client_id_to_shader_cache_.find(client_id);
   // If the cache doesn't exist then this is an off the record profile.
   if (iter == client_id_to_shader_cache_.end())
     return;
   iter->second->Cache(GetShaderPrefixKey() + ":" + key, shader);
 }
 
 }  // namespace content