Mac: Fix janky YouTube animations

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/mac_util.h"
@@ skipping 36 matching lines @@
   // canDrawInCGLContext for other value meanings.
   TRACE_COUNTER_ID1("browser", "PendingSwapAck", this, 2);
 
   has_pending_frame_ = true;
   needs_display_ = true;
   timer_.Reset();
 
   // If reqested, draw immediately and don't bother trying to use the
   // isAsynchronous property to ensure smooth animation.
   if (client_->AcceleratedLayerShouldAckImmediately()) {
-    ImmediatelyForceDisplayAndAck();
+    SetNeedsDisplayAndDisplayAndAck();
   } else {
     if (![layer_ isAsynchronous])
       [layer_ setAsynchronous:YES];
   }
 }
 
 void CompositingIOSurfaceLayerHelper::SetNeedsDisplay() {
   needs_display_ = true;
 }
 
@@ skipping 29 matching lines @@
 
 void CompositingIOSurfaceLayerHelper::AckPendingFrame(bool success) {
   if (!has_pending_frame_)
     return;
   has_pending_frame_ = false;
   client_->AcceleratedLayerDidDrawFrame(success);
   // A trace value of 0 indicates that there is no longer a pending swap ack.
   TRACE_COUNTER_ID1("browser", "PendingSwapAck", this, 0);
 }
 
-void CompositingIOSurfaceLayerHelper::ImmediatelyForceDisplayAndAck() {
+void CompositingIOSurfaceLayerHelper::SetNeedsDisplayAndDisplayAndAck() {
+  // Drawing using setNeedsDisplay and displayIfNeeded will result in
+  // subsequent canDrawInCGLContext callbacks getting dropped, and jerky
+  // animation. Disable asynchronous drawing before issuing these calls as a
+  // workaround.
+  // http://crbug.com/395827
+  if ([layer_ isAsynchronous])
+    [layer_ setAsynchronous:NO];

[Ken Russell (switch to Gerrit), 2014/07/22 19:52:04]

I don't know the various state transitions done to this layer; who sets it back
to asynchronous? If we're in the middle of a scroll (is the layer in async mode
then?) and for some reason we have to display a frame immediately, will the
scroll be aborted abruptly?

[ccameron, 2014/07/23 07:50:34]

It gets re-set to asynchronous as soon as a new frame from the renderer comes
in. The asynchronous mode is a way of making animation smooth -- the synchronous
mode works fine in terms of making forward progress, but can be janky. In these
situations (where we're forcing a display), we're prioritizing getting a frame
up over smoothness (it may be that we'll want to push this prioritization down
to the renderer too, but that's for another day).

+
   [layer_ setNeedsDisplay];
+  DisplayIfNeededAndAck();
+}
+
+void CompositingIOSurfaceLayerHelper::DisplayIfNeededAndAck() {
+  if (!needs_display_)
+    return;
+
+  // As in SetNeedsDisplayAndDisplayAndAck, disable asynchronous drawing before
+  // issuing displayIfNeeded.
+  // http://crbug.com/395827
+  if ([layer_ isAsynchronous])
+    [layer_ setAsynchronous:NO];
+
   [layer_ 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 by lying and claiming that we drew the frame.
   AckPendingFrame(true);
 }
 
 void CompositingIOSurfaceLayerHelper::TimerFired() {
-  ImmediatelyForceDisplayAndAck();
+  SetNeedsDisplayAndDisplayAndAck();
 }
 
 }  // namespace content
 
 ////////////////////////////////////////////////////////////////////////////////
 // CompositingIOSurfaceLayer
 
 @implementation CompositingIOSurfaceLayer
 
 - (content::CompositingIOSurfaceMac*)iosurface {
@@ skipping 34 matching lines @@
 }
 
 - (void)resetClient {
   helper_.reset();
 }
 
 - (void)gotNewFrame {
   helper_->GotNewFrame();
 }
 
+- (void)setNeedsDisplayAndDisplayAndAck {
+  helper_->SetNeedsDisplayAndDisplayAndAck();
+}
+
+- (void)displayIfNeededAndAck {
+  helper_->DisplayIfNeededAndAck();
+}
+
 // The remaining methods implement the CAOpenGLLayer interface.
 
 - (CGLPixelFormatObj)copyCGLPixelFormatForDisplayMask:(uint32_t)mask {
   if (!context_)
     return [super copyCGLPixelFormatForDisplayMask:mask];
   return CGLRetainPixelFormat(CGLGetPixelFormat(context_->cgl_context()));
 }
 
 - (CGLContextObj)copyCGLContextForPixelFormat:(CGLPixelFormatObj)pixelFormat {
   if (!context_)
@@ skipping 46 matching lines @@
   if (helper_)
     helper_->DidDraw(draw_succeeded);
 
   [super drawInCGLContext:glContext
               pixelFormat:pixelFormat
              forLayerTime:timeInterval
               displayTime:timeStamp];
 }
 
 @end