Calculate the refresh period from GLX_OML_sync_control.

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"
 
@@ skipping 39 matching lines @@
 // 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;
 
 bool g_glx_sgi_video_sync_supported = false;
 
 class OMLSyncControlVSyncProvider
     : public gfx::NativeViewGLSurfaceGLX::VSyncProvider {
  public:
   explicit OMLSyncControlVSyncProvider(gfx::AcceleratedWidget window)
-      : window_(window) {
+      : window_(window),
+        last_media_stream_counter_(0) {
+    // On platforms where we can't get an accurate reading on the refresh
+    // rate we fall back to the assumption that we're displaying 60 frames
+    // per second.
+    last_good_interval_ = base::TimeDelta::FromSeconds(1) / 60;
   }
 
   virtual ~OMLSyncControlVSyncProvider() { }
 
   virtual void GetVSyncParameters(
       const GLSurface::UpdateVSyncCallback& callback) OVERRIDE {
     base::TimeTicks timebase;
-    base::TimeDelta interval;
 
     // 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, so we compare the returned time to the
     // current time according to both clocks, and assume that the returned time
     // was produced by the clock whose current time is closest to it, subject
     // to the restriction that the returned time must not be in the future
     // (since it is the time of a vblank that has already occurred).
     int64 system_time;
     int64 media_stream_counter;
@@ skipping 27 matching lines @@
 
     if (time_conversion_needed) {
       int64 time_difference =
         real_time_in_microseconds - monotonic_time_in_microseconds;
       timebase = base::TimeTicks::FromInternalValue(
           system_time - time_difference);
     } else {
       timebase = base::TimeTicks::FromInternalValue(system_time);
     }
 
-    // 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) {
+      int32 numerator, denominator;
       if (glXGetMscRateOML(g_display, window_, &numerator, &denominator)) {
-        interval_time =
-            (base::Time::kMicrosecondsPerSecond * denominator) / numerator;
+        last_good_interval_ =
+            base::TimeDelta::FromSeconds(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;
       }
+    } else {
+      if (!last_timebase_.is_null()) {
+        base::TimeDelta timebase_diff = timebase - last_timebase_;
+        uint64 counter_diff = media_stream_counter -
+            last_media_stream_counter_;
+        if (counter_diff > 0 && timebase > last_timebase_)
+          last_good_interval_ = timebase_diff / counter_diff;
+      }
     }
-    interval = base::TimeDelta::FromMicroseconds(interval_time);
-    callback.Run(timebase, interval);
+    last_timebase_ = timebase;
+    last_media_stream_counter_ = media_stream_counter;
+    callback.Run(timebase, last_good_interval_);
   }
 
  private:
   XID window_;
 
+  base::TimeTicks last_timebase_;
+  uint64 last_media_stream_counter_;
+  base::TimeDelta last_good_interval_;
+
   DISALLOW_COPY_AND_ASSIGN(OMLSyncControlVSyncProvider);
 };
 
 class SGIVideoSyncThread
      : public base::Thread,
        public base::NonThreadSafe,
        public base::RefCounted<SGIVideoSyncThread> {
  public:
   static scoped_refptr<SGIVideoSyncThread> Create() {
     if (!g_video_sync_thread) {
@@ skipping 25 matching lines @@
     : public base::SupportsWeakPtr<SGIVideoSyncProviderThreadShim> {
  public:
   explicit SGIVideoSyncProviderThreadShim(XID window)
       : window_(window),
         context_(NULL),
         message_loop_(base::MessageLoopProxy::current()),
         cancel_vsync_flag_(),
         vsync_lock_() {
     // This ensures that creation of |window_| has occured when this shim
     // is executing in the same process as the call to create |window_|.
-    XSync(::gfx::g_display, False);
+    XSync(g_display, False);
   }
 
   base::CancellationFlag* cancel_vsync_flag() {
     return &cancel_vsync_flag_;
   }
 
   base::Lock* vsync_lock() {
     return &vsync_lock_;
   }
 
   void Initialize() {
-    DCHECK(SGIVideoSyncProviderThreadShim::g_display);
+    DCHECK(display_);
 
     XWindowAttributes attributes;
-    if (!XGetWindowAttributes(SGIVideoSyncProviderThreadShim::g_display,
-                              window_, &attributes)) {
+    if (!XGetWindowAttributes(display_, window_, &attributes)) {
       LOG(ERROR) << "XGetWindowAttributes failed for window " <<
         window_ << ".";
       return;
     }
 
     XVisualInfo visual_info_template;
     visual_info_template.visualid = XVisualIDFromVisual(attributes.visual);
 
     int visual_info_count = 0;
     scoped_ptr_malloc<XVisualInfo, ScopedPtrXFree> visual_info_list(
-        XGetVisualInfo(SGIVideoSyncProviderThreadShim::g_display, VisualIDMask,
+        XGetVisualInfo(display_, VisualIDMask,
                        &visual_info_template, &visual_info_count));
 
     DCHECK(visual_info_list.get());
     if (visual_info_count == 0) {
       LOG(ERROR) << "No visual info for visual ID.";
       return;
     }
 
-    context_ = glXCreateContext(SGIVideoSyncProviderThreadShim::g_display,
-                                visual_info_list.get(),
-                                NULL,
-                                True);
+    context_ = glXCreateContext(display_, visual_info_list.get(), NULL, True);
 
     DCHECK(NULL != context_);
   }
 
   void Destroy() {
     if (context_) {
-      glXDestroyContext(SGIVideoSyncProviderThreadShim::g_display, context_);
+      glXDestroyContext(display_, context_);
       context_ = NULL;
     }
     delete this;
   }
 
   void GetVSyncParameters(const GLSurface::UpdateVSyncCallback& callback) {
     base::TimeTicks now;
     {
       // Don't allow |window_| destruction while we're probing vsync.
       base::AutoLock locked(vsync_lock_);
 
       if (!context_ || cancel_vsync_flag_.IsSet())
         return;
 
-      glXMakeCurrent(SGIVideoSyncProviderThreadShim::g_display,
-                     window_, context_);
+      glXMakeCurrent(display_, window_, context_);
 
       unsigned int retrace_count = 0;
       if (glXWaitVideoSyncSGI(1, 0, &retrace_count) != 0)
         return;
 
       TRACE_EVENT_INSTANT0("gpu", "vblank");
       now = base::TimeTicks::HighResNow();
 
-      glXMakeCurrent(SGIVideoSyncProviderThreadShim::g_display, 0, 0);
+      glXMakeCurrent(display_, 0, 0);
     }
 
-    const int64 kDefaultIntervalTime =
-        base::Time::kMicrosecondsPerSecond / 60;
-    base::TimeDelta interval =
-        base::TimeDelta::FromMicroseconds(kDefaultIntervalTime);
+    const base::TimeDelta kDefaultInterval =
+        base::TimeDelta::FromSeconds(1) / 60;
 
-    message_loop_->PostTask(FROM_HERE, base::Bind(callback, now, interval));
+    message_loop_->PostTask(
+        FROM_HERE, base::Bind(callback, now, kDefaultInterval));
   }
 
  private:
-  // For initialization of g_display in GLSurface::InitializeOneOff before
+  // For initialization of display_ in GLSurface::InitializeOneOff before
   // the sandbox goes up.
   friend class gfx::GLSurfaceGLX;
 
   virtual ~SGIVideoSyncProviderThreadShim() {
   }
 
-  static Display* g_display;
+  static Display* display_;
 
   XID window_;
   GLXContext context_;
 
   scoped_refptr<base::MessageLoopProxy> message_loop_;
 
   base::CancellationFlag cancel_vsync_flag_;
   base::Lock vsync_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(SGIVideoSyncProviderThreadShim);
@@ skipping 60 matching lines @@
   base::Lock* vsync_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(SGIVideoSyncVSyncProvider);
 };
 
 SGIVideoSyncThread* SGIVideoSyncThread::g_video_sync_thread = NULL;
 
 // In order to take advantage of GLX_SGI_video_sync, we need a display
 // for use on a separate thread. We must allocate this before the sandbox
 // goes up (rather than on-demand when we start the thread).
-Display* SGIVideoSyncProviderThreadShim::g_display = NULL;
+Display* SGIVideoSyncProviderThreadShim::display_ = NULL;
 
 }  // namespace
 
 GLSurfaceGLX::GLSurfaceGLX() {}
 
 bool GLSurfaceGLX::InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
@@ skipping 25 matching lines @@
       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;
   g_glx_sgi_video_sync_supported =
       HasGLXExtension("GLX_SGI_video_sync");
 
   if (!g_glx_get_msc_rate_oml_supported && g_glx_sgi_video_sync_supported)
-    SGIVideoSyncProviderThreadShim::g_display = XOpenDisplay(NULL);
+    SGIVideoSyncProviderThreadShim::display_ = XOpenDisplay(NULL);
 
   initialized = true;
   return true;
 }
 
 // static
 const char* GLSurfaceGLX::GetGLXExtensions() {
   return g_glx_extensions;
 }
 
@@ skipping 256 matching lines @@
 
 void* PbufferGLSurfaceGLX::GetConfig() {
   return config_;
 }
 
 PbufferGLSurfaceGLX::~PbufferGLSurfaceGLX() {
   Destroy();
 }
 
 }  // namespace gfx