fix mac frame-rate regression for non-threaded GPU compositing

content/browser/renderer_host/compositing_iosurface_mac.h

 // 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_ACCELERATED_COMPOSITING_VIEW_MAC_H
 #define CONTENT_BROWSER_RENDERER_HOST_ACCELERATED_COMPOSITING_VIEW_MAC_H
 
 #import <Cocoa/Cocoa.h>
+#import <QuartzCore/CVDisplayLink.h>
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/scoped_nsobject.h"
+#include "base/synchronization/lock.h"
+#include "base/time.h"
+#include "base/timer.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/size.h"
 
 class IOSurfaceSupport;
 
 namespace content {
 
 // This class manages an OpenGL context and IOSurface for the accelerated
 // compositing code path. The GL context is attached to
 // RenderWidgetHostViewCocoa for blitting the IOSurface.
@@ skipping 31 matching lines @@
   bool HasIOSurface() { return !!io_surface_.get(); }
 
   const gfx::Size& pixel_io_surface_size() const {
     return pixel_io_surface_size_;
   }
   // In cocoa view units / DIPs.
   const gfx::Size& io_surface_size() const { return io_surface_size_; }
 
   bool is_vsync_disabled() const { return is_vsync_disabled_; }
 
+  // Get vsync scheduling parameters.
+  void GetVSyncParameters(base::TimeTicks* timebase,
+                          uint32* interval_numerator,
+                          uint32* interval_denominator);
+
  private:
+  friend CVReturn DisplayLinkCallback(CVDisplayLinkRef,
+                                      const CVTimeStamp*,
+                                      const CVTimeStamp*,
+                                      CVOptionFlags,
+                                      CVOptionFlags*,
+                                      void*);
+
   // Vertex structure for use in glDraw calls.
   struct SurfaceVertex {
     SurfaceVertex() : x_(0.0f), y_(0.0f), tx_(0.0f), ty_(0.0f) { }
     // Currently the texture coords are always the same as vertex coords.
     void set(float x, float y, float tx, float ty) {
       x_ = x;
       y_ = y;
       tx_ = tx;
       ty_ = ty;
     }
@@ skipping 29 matching lines @@
     }
     SurfaceVertex verts_[4];
   };
 
   CompositingIOSurfaceMac(IOSurfaceSupport* io_surface_support,
                           NSOpenGLContext* glContext,
                           CGLContextObj cglContext,
                           GLuint shader_program_blit_rgb,
                           GLint blit_rgb_sampler_location,
                           GLuint shader_program_white,
-                          bool is_vsync_disabled);
+                          bool is_vsync_disabled,
+                          CVDisplayLinkRef display_link);
 
   // Returns true if IOSurface is ready to render. False otherwise.
   bool MapIOSurfaceToTexture(uint64 io_surface_handle);
 
   void UnrefIOSurfaceWithContextCurrent();
 
   void DrawQuad(const SurfaceQuad& quad);
 
+  // Called on display-link thread.
+  void DisplayLinkTick(CVDisplayLinkRef display_link,
+                       const CVTimeStamp* output_time);
+
+  void CalculateVsyncParametersLockHeld(const CVTimeStamp* time);
+
+  // Prevent from spinning on CGLFlushDrawable when it fails to throttle to
+  // VSync frequency.
+  void RateLimitDraws();
+
+  void StartOrContinueDisplayLink();
+  void StopDisplayLink();
+
   // Cached pointer to IOSurfaceSupport Singleton.
   IOSurfaceSupport* io_surface_support_;
 
   // GL context
   scoped_nsobject<NSOpenGLContext> glContext_;
   CGLContextObj cglContext_;  // weak, backed by |glContext_|.
 
   // IOSurface data.
   uint64 io_surface_handle_;
   base::mac::ScopedCFTypeRef<CFTypeRef> io_surface_;
@@ skipping 10 matching lines @@
   GLuint texture_;
 
   // Shader parameters.
   GLuint shader_program_blit_rgb_;
   GLint blit_rgb_sampler_location_;
   GLuint shader_program_white_;
 
   SurfaceQuad quad_;
 
   bool is_vsync_disabled_;
+
+  // CVDisplayLink for querying Vsync timing info and throttling swaps.
+  CVDisplayLinkRef display_link_;
+
+  // Timer for stopping display link after a timeout with no swaps.
+  base::DelayTimer<CompositingIOSurfaceMac> display_link_stop_timer_;
+
+  // Lock for sharing data between UI thread and display-link thread.
+  base::Lock lock_;
+
+  // Counts for throttling swaps.
+  int64 vsync_count_;
+  int64 swap_count_;
+
+  // Vsync timing data.
+  base::TimeTicks vsync_timebase_;
+  uint32 vsync_interval_numerator_;
+  uint32 vsync_interval_denominator_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_ACCELERATED_COMPOSITING_VIEW_MAC_H