Plumb vsync info from AcceleratedPresenter to RenderWidgetHostImpl

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/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 109 matching lines @@
   if (host) {
     if (alive)
       host->Send(new AcceleratedSurfaceMsg_BufferPresented(route_id, 0));
     else
       host->ForceShutdown();
   }
 }
 
 // This sends a ViewMsg_SwapBuffers_ACK directly to the renderer process
 // (RenderWidget). This path is currently not used with the threaded compositor.
-void AcceleratedSurfaceBuffersSwappedCompletedForRenderer(int surface_id) {
+void AcceleratedSurfaceBuffersSwappedCompletedForRenderer(
+    int surface_id,
+    base::TimeTicks timebase,
+    base::TimeDelta interval) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&AcceleratedSurfaceBuffersSwappedCompletedForRenderer,
-                   surface_id));
+                   surface_id, timebase, interval));
     return;
   }
 
   int render_process_id = 0;
   int render_widget_id = 0;
   if (!GpuSurfaceTracker::Get()->GetRenderWidgetIDForSurface(
       surface_id, &render_process_id, &render_widget_id)) {
     return;
   }
   RenderProcessHost* host = RenderProcessHost::FromID(render_process_id);
   if (!host)
     return;
   RenderWidgetHost* rwh = host->GetRenderWidgetHostByID(render_widget_id);
   if (!rwh)
     return;
   RenderWidgetHostImpl::From(rwh)->AcknowledgeSwapBuffersToRenderer();
+  if (interval != base::TimeDelta())
+    RenderWidgetHostImpl::From(rwh)->UpdateVSyncParameters(timebase, interval);
 }
 
 void AcceleratedSurfaceBuffersSwappedCompleted(int host_id,
                                                int route_id,
                                                int surface_id,
-                                               bool alive) {
+                                               bool alive,
+                                               base::TimeTicks timebase,
+                                               base::TimeDelta interval) {
   AcceleratedSurfaceBuffersSwappedCompletedForGPU(host_id, route_id, alive);
-  AcceleratedSurfaceBuffersSwappedCompletedForRenderer(surface_id);
+  AcceleratedSurfaceBuffersSwappedCompletedForRenderer(surface_id, timebase,
+                                                       interval);
 }
 
 }  // anonymous namespace
 
 #if defined(TOOLKIT_GTK)
 // Used to put a lock on surfaces so that the window to which the GPU
 // process is drawing to doesn't disappear while it is drawing when
 // a WebContents is closed.
 class GpuProcessHost::SurfaceRef {
  public:
@@ skipping 470 matching lines @@
 #endif  // OS_MACOSX
 
 #if defined(OS_WIN) && !defined(USE_AURA)
 
 void GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped");
 
   base::ScopedClosureRunner scoped_completion_runner(
       base::Bind(&AcceleratedSurfaceBuffersSwappedCompleted,
-                 host_id_,
-                 params.route_id,
-                 params.surface_id,
-                 true));
+                 host_id_, params.route_id, params.surface_id,
+                 true, base::TimeTicks(), base::TimeDelta()));
 
   gfx::PluginWindowHandle handle =
       GpuSurfaceTracker::Get()->GetSurfaceWindowHandle(params.surface_id);
   if (!handle) {
     TRACE_EVENT1("gpu", "EarlyOut_SurfaceIDNotFound",
                  "surface_id", params.surface_id);
     return;
   }
 
   scoped_refptr<AcceleratedPresenter> presenter(
@@ skipping 202 matching lines @@
     const IPC::ChannelHandle& channel_handle,
     base::ProcessHandle renderer_process_for_gpu,
     const content::GPUInfo& gpu_info) {
   callback.Run(channel_handle, gpu_info);
 }
 
 void GpuProcessHost::CreateCommandBufferError(
     const CreateCommandBufferCallback& callback, int32 route_id) {
   callback.Run(route_id);
 }