Make --disable-gpu-vsync work with CoreAnimation

content/browser/renderer_host/compositing_iosurface_layer_mac.mm

 // Copyright 2013 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_layer_mac.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 #include <OpenGL/gl.h>
 
 #include "base/mac/sdk_forward_declarations.h"
@@ skipping 39 matching lines @@
   return self;
 }
 
 - (void)disableCompositing{
   ScopedCAActionDisabler disabler;
   [self removeFromSuperlayer];
   renderWidgetHostView_ = nil;
 }
 
 - (void)gotNewFrame {
-  if (![self isAsynchronous]) {
+  if (context_ && context_->is_vsync_disabled()) {
+    // If vsync is disabled, draw immediately and don't bother trying to use
+    // the isAsynchronous property to ensure smooth animation.
     [self setNeedsDisplay];
-    [self setAsynchronous:YES];
+    [self displayIfNeeded];
+
+    // Calls to setNeedsDisplay can sometimes be ignored, especially if issued
+    // rapidly (e.g, with vsync off). This is unacceptable because the failure
+    // to ack a single frame will hang the renderer. Ensure that the renderer
+    // not be blocked.
+    if (needsDisplay_)
+      renderWidgetHostView_->SendPendingSwapAck();

[Ken Russell (switch to Gerrit), 2014/02/20 23:01:53]

If we're mostly sending swap acks upon receiving new frames (gotNewFrame,
timerSinceGotNewFrameFired), is it still necessary to do so inside
CompositorSwapBuffers, which is after the frame is processed (if I remember
correctly)?

Should the code be consistent about where the swap acks are sent? If the system
is fragile to even one lost swap ack, then it seems to me that we should ack
upon receipt of each frame, and never when it's actually processed, if frames
can be dropped by Core Animation for throttling purposes.

[ccameron, 2014/02/21 00:48:23]

CompositorSwapBuffers only does the ack if the frame will not be drawn (it's
hidden, the window is 0x0 in size, etc). CompositorSwapBuffers will not do the
ack if the frame is expected to be drawn -- it will wait for the actual draw
function to complete before doing the ack.
The acks are the mechanism through which the browser can signal back-pressure to
the renderer. I asked brianderson and nduca about this, because it would require
less thought to just ack immediately and communicate backpressure in some way
that would consistently drop the renderer, back to 30fps (for example).

I trust isAsynchronous:YES to always get called in short order (if it doesn't,
we have all sorts of serious issues).

I don't trust setNeedsDisplay, and so I always do the
setNeedsDisplay+displayIfNeeded+ackIfNotDisplayed triplet. This happens in two
cases -- (1) vsync-disabled, which is not-optimal-user-experience territory and
(2) the edge case where you happen to drop out of animating mode while a frame
is pending, a case that will only happen if you somehow suspend the run loop for
a second at the exact wrong moment (highly unlikely, but could happen in
theory).

   } else {
     needsDisplay_ = YES;
+    if (![self isAsynchronous])
+      [self setAsynchronous:YES];
   }
 }
 
 - (void)timerSinceGotNewFrameFired {
   if (![self isAsynchronous])
     return;
 
   [self setAsynchronous:NO];
+
+  // If there was a pending frame, ensure that it goes through.
+  if (needsDisplay_) {
+    [self setNeedsDisplay];
+    [self displayIfNeeded];
+  }
+  // If that fails then ensure that, at a minimum, the renderer is not blocked.
   if (needsDisplay_)
-    [self setNeedsDisplay];
+    renderWidgetHostView_->SendPendingSwapAck();
 }
 
 - (void)waitForResizedFrameInContext:(CGLContextObj)glContext {
   // Cache a copy of renderWidgetHostView_ because it may be reset if
   // a software frame is received in GetBackingStore.
   content::RenderWidgetHostViewMac* cached_view = renderWidgetHostView_;
   if (!cached_view->render_widget_host_ ||
       cached_view->render_widget_host_->is_hidden()) {
     return;
   }
@@ skipping 86 matching lines @@
         context_,
         window_rect,
         window_scale_factor,
         false)) {
     renderWidgetHostView_->GotAcceleratedCompositingError();
     return;
   }
 
   needsDisplay_ = NO;
   renderWidgetHostView_->SendPendingLatencyInfoToHost();
+
+  [super drawInCGLContext:glContext
+              pixelFormat:pixelFormat
+             forLayerTime:timeInterval
+              displayTime:timeStamp];
 }
 
 @end