Send vsync timebase updates to the browser compositor

ui/gl/gl_surface_glx.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.
 
 extern "C" {
 #include <X11/Xlib.h>
 }
 
 #include "ui/gl/gl_surface_glx.h"
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
+#include "base/time.h"
 #include "third_party/mesa/MesaLib/include/GL/osmesa.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_implementation.h"
 
 namespace gfx {
 
 namespace {
 
 // scoped_ptr functor for XFree(). Use as follows:
 //   scoped_ptr_malloc<XVisualInfo, ScopedPtrXFree> foo(...);
 // where "XVisualInfo" is any X type that is freed with XFree.
 class ScopedPtrXFree {
  public:
   void operator()(void* x) const {
     ::XFree(x);
   }
 };
 
 Display* g_display;
 const char* g_glx_extensions = NULL;
 bool g_glx_create_context_robustness_supported = false;
 bool g_glx_texture_from_pixmap_supported = false;
+bool g_glx_oml_sync_control_supported = false;
+
+// Track support of glXGetMscRateOML separately from GLX_OML_sync_control as a
+// whole since on some platforms (e.g. crosbug.com/34585), glXGetMscRateOML
+// always fails even though GLX_OML_sync_control is reported as being supported.
+bool g_glx_get_msc_rate_oml_supported = false;
 
 }  // namespace
 
 GLSurfaceGLX::GLSurfaceGLX() {}
 
 bool GLSurfaceGLX::InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
@@ skipping 12 matching lines @@
   if (major == 1 && minor < 3) {
     LOG(ERROR) << "GLX 1.3 or later is required.";
     return false;
   }
 
   g_glx_extensions = glXQueryExtensionsString(g_display, 0);
   g_glx_create_context_robustness_supported =
       HasGLXExtension("GLX_ARB_create_context_robustness");
   g_glx_texture_from_pixmap_supported =
       HasGLXExtension("GLX_EXT_texture_from_pixmap");
+  g_glx_oml_sync_control_supported =
+      HasGLXExtension("GLX_OML_sync_control");
+  g_glx_get_msc_rate_oml_supported = g_glx_oml_sync_control_supported;
+
 
   initialized = true;
   return true;
 }
 
 // static
 const char* GLSurfaceGLX::GetGLXExtensions() {
   return g_glx_extensions;
 }
 
 // static
 bool GLSurfaceGLX::HasGLXExtension(const char* name) {
   return ExtensionsContain(GetGLXExtensions(), name);
 }
 
 // static
 bool GLSurfaceGLX::IsCreateContextRobustnessSupported() {
   return g_glx_create_context_robustness_supported;
 }
 
 // static
 bool GLSurfaceGLX::IsTextureFromPixmapSupported() {
   return g_glx_texture_from_pixmap_supported;
 }
 
+// static
+bool GLSurfaceGLX::IsOMLSyncControlSupported() {
+  return g_glx_oml_sync_control_supported;
+}
+
 void* GLSurfaceGLX::GetDisplay() {
   return g_display;
 }
 
 GLSurfaceGLX::~GLSurfaceGLX() {}
 
 NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX(gfx::AcceleratedWidget window)
   : window_(window),
     config_(NULL) {
 }
@@ skipping 110 matching lines @@
   return config_;
 }
 
 bool NativeViewGLSurfaceGLX::PostSubBuffer(
     int x, int y, int width, int height) {
   DCHECK(g_GLX_MESA_copy_sub_buffer);
   glXCopySubBufferMESA(g_display, window_, x, y, width, height);
   return true;
 }
 
+bool NativeViewGLSurfaceGLX::GetVSyncParameters(base::TimeTicks* timebase,
+                                                base::TimeDelta* interval) {
+  if (g_glx_oml_sync_control_supported) {

[jonathan.backer, 2012/10/26 20:31:03]

I'm concerned that this may be per monitor (in the multimonitor case with two
different video cards --- not a common configuration I know).

[ajuma, 2012/10/29 17:02:26]

AIUI, since we only XOpenDisplay() once, we're only ever sending GLX calls to a
single GPU.

+    // The actual clock used for the system time returned by glXGetSyncValuesOML
+    // is unspecified. In practice, the clock used is likely to be either
+    // CLOCK_REALTIME or CLOCK_MONOTONIC. We test if the returned time is
+    // "close" (within a minute) to the current time according to either of
+    // these clocks, and if so, we assume that the corresponding clock was used
+    // to produce this time.
+    int64 system_time;
+    int64 media_stream_counter;
+    int64 swap_buffer_counter;
+    if (glXGetSyncValuesOML(g_display, window_, &system_time,
+                            &media_stream_counter, &swap_buffer_counter)) {
+      struct timespec real_time;
+      struct timespec monotonic_time;
+      clock_gettime(CLOCK_REALTIME, &real_time);
+      clock_gettime(CLOCK_MONOTONIC, &monotonic_time);
+
+      int64 real_time_in_microseconds =
+          real_time.tv_sec * base::Time::kMicrosecondsPerSecond +
+          real_time.tv_nsec / base::Time::kNanosecondsPerMicrosecond;
+      int64 monotonic_time_in_microseconds =
+          monotonic_time.tv_sec * base::Time::kMicrosecondsPerSecond +
+          monotonic_time.tv_nsec / base::Time::kNanosecondsPerMicrosecond;
+
+      if (real_time_in_microseconds - system_time <=
+          base::Time::kMicrosecondsPerMinute) {
+        // Convert from CLOCK_REALTIME to CLOCK_MONOTONIC.
+        int64 time_difference =
+            real_time_in_microseconds - monotonic_time_in_microseconds;
+        *timebase = base::TimeTicks::FromInternalValue(
+            system_time - time_difference);
+      } else if (monotonic_time_in_microseconds - system_time <=
+          base::Time::kMicrosecondsPerMinute) {
+        *timebase = base::TimeTicks::FromInternalValue(system_time);
+      } else {
+        // We don't know how to interpret system_time.
+        return false;
+      }
+
+      // On platforms where glXGetMscRateOML doesn't work, we fall back to the
+      // assumption that we're displaying 60 frames per second.
+      const int64 kDefaultIntervalTime =
+          base::Time::kMicrosecondsPerSecond / 60;
+      int64 interval_time = kDefaultIntervalTime;
+      int32 numerator;
+      int32 denominator;
+      if (g_glx_get_msc_rate_oml_supported) {
+          if (glXGetMscRateOML(g_display, window_, &numerator, &denominator)) {
+            interval_time =
+                (base::Time::kMicrosecondsPerSecond * denominator) / numerator;
+          } else {
+            // Once glXGetMscRateOML has been found to fail, don't try again,
+            // since each failing call may spew an error message.
+            g_glx_get_msc_rate_oml_supported = false;
+          }
+      }
+
+      *interval = base::TimeDelta::FromMicroseconds(interval_time);
+      return true;
+    }
+  }
+
+  return false;
+}
+
 NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX()
   : window_(0),
     config_(NULL) {
 }
 
 NativeViewGLSurfaceGLX::~NativeViewGLSurfaceGLX() {
   Destroy();
 }
 
 PbufferGLSurfaceGLX::PbufferGLSurfaceGLX(const gfx::Size& size)
@@ skipping 79 matching lines @@
 
 void* PbufferGLSurfaceGLX::GetConfig() {
   return config_;
 }
 
 PbufferGLSurfaceGLX::~PbufferGLSurfaceGLX() {
   Destroy();
 }
 
 }  // namespace gfx