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(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 93 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 34 matching lines @@
     Resize(new_size_);
   }
 }
 
 gfx::Size PassThroughImageTransportSurface::GetSize() {
   return GLSurfaceAdapter::GetSize();
 }
 
 PassThroughImageTransportSurface::~PassThroughImageTransportSurface() {}
 
+void PassThroughImageTransportSurface::SendVSyncUpdateIfAvailable() {
+  int64 monotonicTime;
+  int64 mediaStreamCounter;
+  int64 swapBufferCounter;
+
+  // TODO: Use glXGetMscRateOML (where available) to get the correct interval
+  // time. If unavailable, we should plumb-in information about when we
+  // clock down.
+  const int64 intervalTime = base::Time::kMicrosecondsPerSecond / 60;

[piman, 2012/10/24 16:56:54]

This sounds like it belongs to GLSurfaceGLX too.

[ajuma, 2012/10/26 20:12:39]

Done.

+
+  if (GetSyncValues(&monotonicTime, &mediaStreamCounter, &swapBufferCounter)) {
+    base::TimeTicks timebase = base::TimeTicks::FromInternalValue(
+        monotonicTime);
+    base::TimeDelta interval = base::TimeDelta::FromMicroseconds(intervalTime);
+    helper_->SendUpdateVSyncParameters(timebase, interval);
+  }
+}
+
 }  // namespace content
 
 #endif  // defined(ENABLE_GPU)