Hook up Mac OSX VSync parameters to compositor thread

content/browser/renderer_host/compositing_iosurface_mac.mm

 // 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.
 
 #include "content/browser/renderer_host/compositing_iosurface_mac.h"
 
 #include <OpenGL/OpenGL.h>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/threading/platform_thread.h"
-#include "content/browser/renderer_host/render_widget_host_view_mac.h"
 #include "content/public/browser/browser_thread.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/surface/io_surface_support_mac.h"
 
 #ifdef NDEBUG
 #define CHECK_GL_ERROR()
@@ skipping 230 matching lines @@
     CalculateVsyncParametersLockHeld(&cv_time);
   }
 
   // Stop display link for now, it will be started when needed during Draw.
   StopDisplayLink();
 }
 
 void CompositingIOSurfaceMac::GetVSyncParameters(base::TimeTicks* timebase,
                                                  uint32* interval_numerator,
                                                  uint32* interval_denominator) {
+  base::AutoLock lock(lock_);
   *timebase = vsync_timebase_;
   *interval_numerator = vsync_interval_numerator_;
   *interval_denominator = vsync_interval_denominator_;
 }
 
 CompositingIOSurfaceMac::~CompositingIOSurfaceMac() {
   CVDisplayLinkRelease(display_link_);
   UnrefIOSurface();
 }
 
@@ skipping 271 matching lines @@
 void CompositingIOSurfaceMac::GlobalFrameDidChange() {
   [glContext_ update];
 }
 
 void CompositingIOSurfaceMac::ClearDrawable() {
   [glContext_ clearDrawable];
   UnrefIOSurface();
 }
 
 void CompositingIOSurfaceMac::DisplayLinkTick(CVDisplayLinkRef display_link,
-                                              const CVTimeStamp* output_time) {
+                                              const CVTimeStamp* time) {
+  TRACE_EVENT0("gpu", "CompositingIOSurfaceMac::DisplayLinkTick");
   base::AutoLock lock(lock_);
   // Increment vsync_count but don't let it get ahead of swap_count.
   vsync_count_ = std::min(vsync_count_ + 1, swap_count_);
 
-  CalculateVsyncParametersLockHeld(output_time);
+  CalculateVsyncParametersLockHeld(time);
 }
 
 void CompositingIOSurfaceMac::CalculateVsyncParametersLockHeld(
     const CVTimeStamp* time) {
+  lock_.AssertAcquired();
   vsync_interval_numerator_ = static_cast<uint32>(time->videoRefreshPeriod);
   vsync_interval_denominator_ = time->videoTimeScale;
   // Verify that videoRefreshPeriod is 32 bits.
   DCHECK((time->videoRefreshPeriod & ~0xffffFFFFull) == 0ull);
 
   vsync_timebase_ =
       base::TimeTicks::FromInternalValue(time->hostTime / 1000);
 }
 
 void CompositingIOSurfaceMac::RateLimitDraws() {
@@ skipping 30 matching lines @@
   }
   display_link_stop_timer_.Reset();
 }
 
 void CompositingIOSurfaceMac::StopDisplayLink() {
   if (CVDisplayLinkIsRunning(display_link_))
     CVDisplayLinkStop(display_link_);
 }
 
 }  // namespace content