Send vsync timebase updates to the browser compositor

content/common/gpu/image_transport_surface.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.
 
 #if defined(ENABLE_GPU)
 
 #include "content/common/gpu/image_transport_surface.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 139 matching lines @@
   params.route_id = route_id_;
   manager_->Send(new GpuHostMsg_AcceleratedSurfaceRelease(params));
 }
 
 void ImageTransportHelper::SendResizeView(const gfx::Size& size) {
   manager_->Send(new GpuHostMsg_ResizeView(stub_->surface_id(),
                                            route_id_,
                                            size));
 }
 
+void ImageTransportHelper::SendUpdateVSyncParameters(
+      base::TimeTicks timebase, base::TimeDelta interval) {
+  manager_->Send(new GpuHostMsg_UpdateVSyncParameters(stub_->surface_id(),
+                                                      timebase,
+                                                      interval));
+}
+
 void ImageTransportHelper::SetScheduled(bool is_scheduled) {
   gpu::GpuScheduler* scheduler = Scheduler();
   if (!scheduler)
     return;
 
   scheduler->SetScheduled(is_scheduled);
 }
 
 void ImageTransportHelper::DeferToFence(base::Closure task) {
   gpu::GpuScheduler* scheduler = Scheduler();
@@ skipping 94 matching lines @@
   return helper_->Initialize();
 }
 
 void PassThroughImageTransportSurface::Destroy() {
   helper_->Destroy();
   GLSurfaceAdapter::Destroy();
 }
 
 bool PassThroughImageTransportSurface::SwapBuffers() {
   bool result = gfx::GLSurfaceAdapter::SwapBuffers();
+  SendVSyncUpdateIfAvailable();
 
   if (transport_) {
     // Round trip to the browser UI thread, for throttling, by sending a dummy
     // SwapBuffers message.
     GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
     params.surface_handle = 0;
     helper_->SendAcceleratedSurfaceBuffersSwapped(params);
 
     helper_->SetScheduled(false);
   }
   return result;
 }
 
 bool PassThroughImageTransportSurface::PostSubBuffer(
     int x, int y, int width, int height) {
   bool result = gfx::GLSurfaceAdapter::PostSubBuffer(x, y, width, height);
+  SendVSyncUpdateIfAvailable();
 
   if (transport_) {
     // Round trip to the browser UI thread, for throttling, by sending a dummy
     // PostSubBuffer message.
     GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params params;
     params.surface_handle = 0;
     params.x = x;
     params.y = y;
     params.width = width;
     params.height = height;
@@ skipping 36 matching lines @@
     Resize(new_size_);
   }
 }
 
 gfx::Size PassThroughImageTransportSurface::GetSize() {
   return GLSurfaceAdapter::GetSize();
 }
 
 PassThroughImageTransportSurface::~PassThroughImageTransportSurface() {}
 
+void PassThroughImageTransportSurface::SendVSyncUpdateIfAvailable() {
+// TODO (ajuma): Fix up the browser-side handling of these updates on
+// non-Aura, so we can remove this ifdef.
+#if defined(USE_AURA)

[piman, 2012/10/29 20:36:39]

No ifdef AURA in the GPU-process code. Aura is a UI-concept and shouldn't leak
here.
Possibly what you mean is to check whether this surface is a "transport" one
(i.e. representing a renderer), or not?

[ajuma, 2012/10/30 21:04:04]

I've removed the ifdef. It turns out that not much code is needed to add support
for the desktop Linux case (to handle the message in the browser and forward the
vsync parameters to the appropriate renderer), so I've added this code in
GpuProcessHostUIShim.

+  base::TimeTicks timebase;
+  base::TimeDelta interval;
+  if (GetVSyncParameters(&timebase, &interval)) {
+    helper_->SendUpdateVSyncParameters(timebase, interval);
+  }
+#endif
+}
+
 }  // namespace content
 
 #endif  // defined(ENABLE_GPU)