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 249 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 systemTime;
+  int64 mediaStreamCounter;
+  int64 swapBufferCounter;
+
+  // GetSyncValues gives us a time from CLOCK_REALTIME, but we need
+  // a time from CLOCK_MONOTONIC, so we convert.
+  static bool conversionComputed = false;
+  static int64 timeDifference = 0;
+
+  // This assumes that the difference between Unix epoch time and system
+  // uptime remains constant throughout the life of this process, but this
+  // may not be true (e.g. the user may adjust the clock). We should either
+  // recompute this periodically, or (if it's cheap enough) recompute this
+  // everytime.
+  if (!conversionComputed) {
+      struct timespec realTime;
+      struct timespec monotonicTime;
+      clock_gettime(CLOCK_REALTIME, &realTime);
+      clock_gettime(CLOCK_MONOTONIC, &monotonicTime);

[piman, 2012/10/17 17:24:47]

PassThroughImageTransportSurface is cross-platform code, so this won't work.
It sounds like any conversion you'd want to do belongs into GLSurfaceGLX.

+
+      int64 realTimeInMicroseconds =
+        realTime.tv_sec * base::Time::kMicrosecondsPerSecond +
+        realTime.tv_nsec / base::Time::kNanosecondsPerMicrosecond;
+
+      int64 monotonicTimeInMicroseconds =
+        monotonicTime.tv_sec * base::Time::kMicrosecondsPerSecond +
+        monotonicTime.tv_nsec / base::Time::kNanosecondsPerMicrosecond;
+
+      timeDifference = realTimeInMicroseconds - monotonicTimeInMicroseconds;
+      conversionComputed = true;
+  }
+
+  if (GetSyncValues(&systemTime, &mediaStreamCounter, &swapBufferCounter)) {
+    int64 monotonicVSyncTime = systemTime - timeDifference;
+    helper_->stub()->SendUpdateVSyncTime(monotonicVSyncTime);
+  }
+}
+
 #endif  // defined(ENABLE_GPU)