Make --disable-gpu-vsync work with CoreAnimation

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"
 
 #import <objc/runtime.h>
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/basictypes.h"
@@ skipping 1313 matching lines @@
     render_widget_host_->Send(new ViewMsg_PluginImeCompositionCompleted(
         render_widget_host_->GetRoutingID(), text, plugin_id));
   }
 }
 
 void RenderWidgetHostViewMac::CompositorSwapBuffers(
     uint64 surface_handle,
     const gfx::Size& size,
     float surface_scale_factor,
     const std::vector<ui::LatencyInfo>& latency_info) {
+  // Ensure that the frame be acked unless it is explicitly passed to a
+  // display function.
+  base::ScopedClosureRunner scoped_ack(
+      base::Bind(&RenderWidgetHostViewMac::SendPendingSwapAck,
+                 weak_factory_.GetWeakPtr()));
+
   if (render_widget_host_->is_hidden())
     return;
 
   AddPendingLatencyInfo(latency_info);
 
   NSWindow* window = [cocoa_view_ window];
   if (window_number() <= 0) {
     // There is no window to present so capturing during present won't work.
     // We check if frame subscriber wants this frame and capture manually.
     if (compositing_iosurface_ && frame_subscriber_) {
       const base::TimeTicks present_time = base::TimeTicks::Now();
       scoped_refptr<media::VideoFrame> frame;
       RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback;
       if (frame_subscriber_->ShouldCaptureFrame(present_time,
                                                 &frame, &callback)) {
         gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
             compositing_iosurface_context_->cgl_context());
         compositing_iosurface_->SetIOSurfaceWithContextCurrent(
             compositing_iosurface_context_, surface_handle, size,
             surface_scale_factor);
         compositing_iosurface_->CopyToVideoFrame(
             gfx::Rect(size), frame,
             base::Bind(callback, present_time));
-        SendPendingSwapAck();
         return;
       }
     }
 
     // TODO(shess) If the view does not have a window, or the window
     // does not have backing, the IOSurface will log "invalid drawable"
     // in -setView:.  It is not clear how this code is reached with such
     // a case, so record some info into breakpad (some subset of
     // browsers are likely to crash later for unrelated reasons).
     // http://crbug.com/148882
@@ skipping 65 matching lines @@
   gfx::Size window_size(NSSizeToCGSize([cocoa_view_ frame].size));
   if (window_size.IsEmpty()) {
     // setNeedsDisplay will never display and we'll never ack if the window is
     // empty, so ack now and don't bother calling setNeedsDisplay below.
     return;
   }
 
   // No need to draw the surface if we are inside a drawRect. It will be done
   // later.
   if (!about_to_validate_and_paint_) {
+    scoped_ack.Reset();
     if (use_core_animation_) {
       DCHECK(compositing_iosurface_layer_);
       compositing_iosurface_layer_async_timer_.Reset();
       [compositing_iosurface_layer_ gotNewFrame];
     } else {
       if (!DrawIOSurfaceWithoutCoreAnimation()) {
         [cocoa_view_ setNeedsDisplay:YES];
         GotAcceleratedCompositingError();
         return;
       }
@@ skipping 236 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   AddPendingSwapAck(params.route_id,
                     gpu_host_id,
                     compositing_iosurface_ ?
                         compositing_iosurface_->GetRendererID() : 0);
   CompositorSwapBuffers(params.surface_handle,
                         params.size,
                         params.scale_factor,
                         params.latency_info);
-  // TODO(ccameron): This ack should not be needed, and will inappropriately
-  // remove GPU back-pressure. Remove this.
-  SendPendingSwapAck();
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   TRACE_EVENT0("browser",
       "RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer");
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   AddPendingSwapAck(params.route_id,
                     gpu_host_id,
                     compositing_iosurface_ ?
                         compositing_iosurface_->GetRendererID() : 0);
   CompositorSwapBuffers(params.surface_handle,
                         params.surface_size,
                         params.surface_scale_factor,
                         params.latency_info);
-  // TODO(ccameron): This ack should not be needed, and will inappropriately
-  // remove GPU back-pressure. Remove this.
-  SendPendingSwapAck();
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceSuspend() {
   if (compositing_iosurface_)
     compositing_iosurface_->UnrefIOSurface();
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceRelease() {
   DestroyCompositedIOSurfaceAndLayer(kDestroyContext);
 }
@@ skipping 152 matching lines @@
   weak_factory_.InvalidateWeakPtrs();
   render_widget_host_->Shutdown();
   // Do not touch any members at this point, |this| has been deleted.
 }
 
 void RenderWidgetHostViewMac::GotAcceleratedFrame() {
   // Update the host with VSync parametrs.
   base::TimeTicks timebase;
   base::TimeDelta interval;
   if (compositing_iosurface_context_ &&
+      compositing_iosurface_context_->display_link() &&
       compositing_iosurface_context_->display_link()->GetVSyncParameters(
           &timebase, &interval)) {
     render_widget_host_->UpdateVSyncParameters(timebase, interval);
   }
 
   if (!last_frame_was_accelerated_) {
     last_frame_was_accelerated_ = true;
 
     if (!use_core_animation_) {
       // Need to wipe the software view with transparency to expose the GL
@@ skipping 183 matching lines @@
   [software_layer_ setNeedsDisplay];
   [compositing_iosurface_layer_ setNeedsDisplay];
 }
 
 void RenderWidgetHostViewMac::AddPendingSwapAck(
     int32 route_id, int gpu_host_id, int32 renderer_id) {
   // Note that multiple un-acked swaps can come in the event of a GPU process
   // loss. Drop the old acks.
   pending_swap_ack_.reset(new PendingSwapAck(
       route_id, gpu_host_id, renderer_id));
-  // Ack this immediately if we're already inside a paint call, or if we're
-  // hidden and this may not paint for a long time.
-  if (about_to_validate_and_paint_ || render_widget_host_->is_hidden())
-    SendPendingSwapAck();
 }
 
 void RenderWidgetHostViewMac::SendPendingSwapAck() {
   if (!pending_swap_ack_)
     return;
 
   AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
   ack_params.sync_point = 0;
   ack_params.renderer_id = pending_swap_ack_->renderer_id;
   RenderWidgetHostImpl::AcknowledgeBufferPresent(pending_swap_ack_->route_id,
@@ skipping 2024 matching lines @@
   return YES;
 }
 
 - (BOOL)isOpaque {
   if (renderWidgetHostView_->use_core_animation_)
     return YES;
   return [super isOpaque];
 }
 
 @end