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

content/browser/renderer_host/render_widget_host_view_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/render_widget_host_view_mac.h"
 
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 359 matching lines @@
       about_to_validate_and_paint_(false),
       call_set_needs_display_in_rect_pending_(false),
       last_frame_was_accelerated_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       can_compose_inline_(true),
       allow_overlapping_views_(false),
       use_core_animation_(false),
       is_loading_(false),
       is_hidden_(false),
       weak_factory_(this),
-      fullscreen_parent_host_view_(NULL) {
+      fullscreen_parent_host_view_(NULL),
+      pending_swap_buffers_acks_weak_factory_(this),
+      next_swap_ack_time_(base::Time::Now()) {
   // |cocoa_view_| owns us and we will be deleted when |cocoa_view_|
   // goes away.  Since we autorelease it, our caller must put
   // |GetNativeView()| into the view hierarchy right after calling us.
   cocoa_view_ = [[[RenderWidgetHostViewCocoa alloc]
                   initWithRenderWidgetHostViewMac:this] autorelease];
 
   if (GetCoreAnimationStatus() == CORE_ANIMATION_ENABLED_ALWAYS) {
     EnableCoreAnimation();
   }
 
@@ skipping 864 matching lines @@
     } else {
       compositing_iosurface_->DrawIOSurface(this);
     }
   }
 
   if (should_post_notification && [[cocoa_view_ delegate]
           respondsToSelector:@selector(compositingIOSurfaceCreated)]) {
     [[cocoa_view_ delegate] compositingIOSurfaceCreated];
   }
 
-  // Don't ack the new frame until it is drawn.
-  if (use_core_animation_)
-    return false;
-
   return true;
 }
 
 void RenderWidgetHostViewMac::AckPendingSwapBuffers() {
   TRACE_EVENT0("browser", "RenderWidgetHostViewMac::AckPendingSwapBuffers");
+
+  // Cancel any outstanding delayed calls to this function.
+  pending_swap_buffers_acks_weak_factory_.InvalidateWeakPtrs();
+
   while (!pending_swap_buffers_acks_.empty()) {
     if (pending_swap_buffers_acks_.front().first != 0) {
       AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
       ack_params.sync_point = 0;
       if (compositing_iosurface_)
         ack_params.renderer_id = compositing_iosurface_->GetRendererID();
       RenderWidgetHostImpl::AcknowledgeBufferPresent(
           pending_swap_buffers_acks_.front().first,
           pending_swap_buffers_acks_.front().second,
           ack_params);
       if (render_widget_host_) {
         render_widget_host_->AcknowledgeSwapBuffersToRenderer();
-
-        // Send VSync parameters to compositor thread.
-        if (compositing_iosurface_) {
-          base::TimeTicks timebase;
-          uint32 numerator = 0, denominator = 0;
-          compositing_iosurface_->GetVSyncParameters(&timebase,
-                                                     &numerator,
-                                                     &denominator);
-          if (numerator > 0 && denominator > 0) {
-            int64 interval_micros =
-                1000000 * static_cast<int64>(numerator) / denominator;
-            render_widget_host_->UpdateVSyncParameters(
-                timebase, base::TimeDelta::FromMicroseconds(interval_micros));
-          } else {
-            // Pass reasonable default values if unable to get the actual ones
-            // (e.g. CVDisplayLink failed to return them because the display is
-            // in sleep mode).
-            static const int64 kOneOverSixtyMicroseconds = 16669;
-            render_widget_host_->UpdateVSyncParameters(
-                base::TimeTicks::Now(),
-                base::TimeDelta::FromMicroseconds(kOneOverSixtyMicroseconds));
-          }
-        }
       }
     }
     pending_swap_buffers_acks_.erase(pending_swap_buffers_acks_.begin());
   }
 }
 
+void RenderWidgetHostViewMac::ThrottledAckPendingSwapBuffers() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // Send VSync parameters to the renderer's compositor thread.
+  base::TimeTicks vsync_timebase;
+  base::TimeDelta vsync_interval;
+  GetVSyncParameters(&vsync_timebase, &vsync_interval);
+  if (render_widget_host_ && compositing_iosurface_)
+    render_widget_host_->UpdateVSyncParameters(vsync_timebase, vsync_interval);
+
+  // If the render widget host is responsible for throttling swaps to vsync rate
+  // then don't ack the swapbuffers until a full vsync has passed since the last
+  // ack was sent.
+  bool throttle_swap_ack =
+      render_widget_host_ &&
+      !render_widget_host_->is_threaded_compositing_enabled() &&
+      compositing_iosurface_ &&
+      !compositing_iosurface_->is_vsync_disabled();
+  base::Time now = base::Time::Now();
+  if (throttle_swap_ack && next_swap_ack_time_ > now) {
+    base::TimeDelta next_swap_ack_delay = next_swap_ack_time_ - now;
+    next_swap_ack_time_ += vsync_interval;
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&RenderWidgetHostViewMac::AckPendingSwapBuffers,
+                   pending_swap_buffers_acks_weak_factory_.GetWeakPtr()),
+        next_swap_ack_delay);
+  } else {
+    next_swap_ack_time_ = now + vsync_interval;
+    AckPendingSwapBuffers();
+  }
+}
+
+void RenderWidgetHostViewMac::GetVSyncParameters(
+  base::TimeTicks* timebase, base::TimeDelta* interval) {
+  if (compositing_iosurface_) {
+    uint32 numerator = 0;
+    uint32 denominator = 0;
+    compositing_iosurface_->GetVSyncParameters(
+        timebase, &numerator, &denominator);
+    if (numerator > 0 && denominator > 0) {
+      int64 interval_micros =
+          1000000 * static_cast<int64>(numerator) / denominator;
+      *interval = base::TimeDelta::FromMicroseconds(interval_micros);
+      return;
+    }
+  }
+
+  // Pass reasonable default values if unable to get the actual ones
+  // (e.g. CVDisplayLink failed to return them because the display is
+  // in sleep mode).
+  static const int64 kOneOverSixtyMicroseconds = 16669;
+  *timebase = base::TimeTicks::Now(),
+  *interval = base::TimeDelta::FromMicroseconds(kOneOverSixtyMicroseconds);
+}
+
 bool RenderWidgetHostViewMac::GetLineBreakIndex(
     const std::vector<gfx::Rect>& bounds,
     const ui::Range& range,
     size_t* line_break_point) {
   DCHECK(line_break_point);
   if (range.start() >= bounds.size() || range.is_reversed() || range.is_empty())
     return false;
 
   // We can't check line breaking completely from only rectangle array. Thus we
   // assume the line breaking as the next character's y offset is larger than
@@ skipping 118 matching lines @@
   TRACE_EVENT0("browser",
       "RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped");
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   pending_swap_buffers_acks_.push_back(std::make_pair(params.route_id,
                                                       gpu_host_id));
 
   if (CompositorSwapBuffers(params.surface_handle,
                             params.size,
                             params.scale_factor,
-                            params.latency_info))
-    AckPendingSwapBuffers();
+                            params.latency_info)) {
+    if (!use_core_animation_)
+      ThrottledAckPendingSwapBuffers();
+  }
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   TRACE_EVENT0("browser",
       "RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer");
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   pending_swap_buffers_acks_.push_back(std::make_pair(params.route_id,
                                                       gpu_host_id));
 
   if (CompositorSwapBuffers(params.surface_handle,
                             params.surface_size,
                             params.surface_scale_factor,
-                            params.latency_info))
-    AckPendingSwapBuffers();
+                            params.latency_info)) {
+    if (!use_core_animation_)
+      ThrottledAckPendingSwapBuffers();
+  }
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceSuspend() {
   if (compositing_iosurface_)
     compositing_iosurface_->UnrefIOSurface();
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceRelease() {
   DestroyCompositedIOSurfaceAndLayer();
 }
@@ skipping 2155 matching lines @@
   return YES;
 }
 
 - (BOOL)isOpaque {
   if (renderWidgetHostView_->use_core_animation_)
     return YES;
   return [super isOpaque];
 }
 
 @end