Don't use a sleep in the browser's main thread to throttle swapbuffers.

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/CGLRenderers.h>
 #include <OpenGL/OpenGL.h>
 
 #include "base/bind.h"
@@ skipping 262 matching lines @@
       texture_(0),
       finish_copy_timer_(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kFinishCopyPollingPeriodMs),
           base::Bind(&CompositingIOSurfaceMac::FinishAllCopies,
                      base::Unretained(this)),
           true),
       display_link_(0),
       display_link_stop_timer_(FROM_HERE, base::TimeDelta::FromSeconds(1),
                                this, &CompositingIOSurfaceMac::StopDisplayLink),
-      vsync_count_(0),
-      swap_count_(0),
       vsync_interval_numerator_(0),
       vsync_interval_denominator_(0),
       initialized_is_intel_(false),
       is_intel_(false),
       screen_(0) {
 }
 
 void CompositingIOSurfaceMac::SetupCVDisplayLink() {
   if (display_link_) {
     LOG(ERROR) << "DisplayLink already setup";
@@ skipping 263 matching lines @@
 
   if (!using_core_animation)
     CGLSetCurrentContext(0);
 
   if (!copy_done_callback.is_null())
     copy_done_callbacks.push_back(copy_done_callback);
   for (size_t i = 0; i < copy_done_callbacks.size(); ++i)
     copy_done_callbacks[i].Run();
 
   StartOrContinueDisplayLink();
-
-  if (!is_vsync_disabled())
-    RateLimitDraws();
 }
 
 void CompositingIOSurfaceMac::CopyTo(
       const gfx::Rect& src_pixel_subrect,
       const gfx::Size& dst_pixel_size,
       const base::Callback<void(bool, const SkBitmap&)>& callback) {
   scoped_ptr<SkBitmap> output(new SkBitmap());
   output->setConfig(SkBitmap::kARGB_8888_Config,
                     dst_pixel_size.width(), dst_pixel_size.height());
   if (!output->allocPixels()) {
@@ skipping 152 matching lines @@
 
 void CompositingIOSurfaceMac::ClearDrawable() {
   [context_->nsgl_context() clearDrawable];
   UnrefIOSurface();
 }
 
 void CompositingIOSurfaceMac::DisplayLinkTick(CVDisplayLinkRef display_link,
                                               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(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() {
-  int64 vsync_count;
-  int64 swap_count;
-
-  {
-    base::AutoLock lock(lock_);
-    vsync_count = vsync_count_;
-    swap_count = ++swap_count_;
-  }
-
-  // It's OK for swap_count to get 2 ahead of vsync_count, but any more
-  // indicates that it has become unthrottled. This happens when, for example,
-  // the window is obscured by another opaque window.
-  if (swap_count > vsync_count + 2) {
-    TRACE_EVENT0("gpu", "CompositingIOSurfaceMac::RateLimitDraws");
-    // Sleep for one vsync interval. This will prevent spinning while the window
-    // is not visible, but will also allow quick recovery when the window
-    // becomes visible again.
-    int64 sleep_us = 16666;  // default to 60hz if display link API fails.
-    if (vsync_interval_denominator_ > 0) {
-      sleep_us = (static_cast<int64>(vsync_interval_numerator_) * 1000000) /
-                 vsync_interval_denominator_;
-    }
-    base::PlatformThread::Sleep(base::TimeDelta::FromMicroseconds(sleep_us));
-  }
-}
-
 void CompositingIOSurfaceMac::StartOrContinueDisplayLink() {
   if (display_link_ == NULL)
     return;
 
   if (!CVDisplayLinkIsRunning(display_link_)) {
-    vsync_count_ = swap_count_ = 0;
     CVDisplayLinkStart(display_link_);
   }
   display_link_stop_timer_.Reset();
 }
 
 void CompositingIOSurfaceMac::StopDisplayLink() {
   if (display_link_ == NULL)
     return;
 
   if (CVDisplayLinkIsRunning(display_link_))
@@ skipping 302 matching lines @@
   }
 }
 
 gfx::Rect CompositingIOSurfaceMac::IntersectWithIOSurface(
     const gfx::Rect& rect) const {
   return gfx::IntersectRects(rect,
       gfx::ToEnclosingRect(gfx::Rect(pixel_io_surface_size_)));
 }
 
 }  // namespace content