Fix assorted issues with remote CoreAnimation

content/common/gpu/image_transport_surface_calayer_mac.mm

 // Copyright 2014 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/common/gpu/image_transport_surface_calayer_mac.h"
 
+#include "base/command_line.h"
 #include "base/mac/sdk_forward_declarations.h"
 #include "content/common/gpu/surface_handle_types_mac.h"
 #include "ui/base/cocoa/animation_utils.h"
 #include "ui/gfx/geometry/size_conversions.h"
+#include "ui/gl/gl_gl_api_implementation.h"
+#include "ui/gl/gl_switches.h"
 
 @interface ImageTransportLayer : CAOpenGLLayer {
   content::CALayerStorageProvider* storageProvider_;
 }
 - (id)initWithStorageProvider:(content::CALayerStorageProvider*)storageProvider;
 - (void)resetStorageProvider;
 @end
 
 @implementation ImageTransportLayer
 
 - (id)initWithStorageProvider:
     (content::CALayerStorageProvider*)storageProvider {
   if (self = [super init])
     storageProvider_ = storageProvider;
   return self;
 }
 
 - (void)resetStorageProvider {
+  if (storageProvider_)
+    storageProvider_->LayerResetStorageProvider();
   storageProvider_ = NULL;
 }
 
 - (CGLPixelFormatObj)copyCGLPixelFormatForDisplayMask:(uint32_t)mask {
   if (!storageProvider_)
     return NULL;
   return CGLRetainPixelFormat(CGLGetPixelFormat(
       storageProvider_->LayerShareGroupContext()));
 }
 
@@ skipping 14 matching lines @@
                 displayTime:(const CVTimeStamp*)timeStamp {
   if (!storageProvider_)
     return NO;
   return storageProvider_->LayerCanDraw();
 }
 
 - (void)drawInCGLContext:(CGLContextObj)glContext
              pixelFormat:(CGLPixelFormatObj)pixelFormat
             forLayerTime:(CFTimeInterval)timeInterval
              displayTime:(const CVTimeStamp*)timeStamp {
+  // While in this callback, CoreAnimation has set |glContext| to be current.
+  // Ensure that the GL calls that we make are made against the native GL API.
+  gfx::ScopedSetGLToRealGLApi scoped_set_gl_api;
+
   if (storageProvider_) {
     storageProvider_->LayerDoDraw();
   } else {
     glClearColor(1, 1, 1, 1);
     glClear(GL_COLOR_BUFFER_BIT);
   }
   [super drawInCGLContext:glContext
               pixelFormat:pixelFormat
              forLayerTime:timeInterval
               displayTime:timeStamp];
 }
 
 @end
 
 namespace content {
 
 CALayerStorageProvider::CALayerStorageProvider(
     ImageTransportSurfaceFBO* transport_surface)
         : transport_surface_(transport_surface),
+          gpu_vsync_disabled_(CommandLine::ForCurrentProcess()->HasSwitch(
+              switches::kDisableGpuVsync)),
           has_pending_draw_(false),
           can_draw_returned_false_count_(0),
-          fbo_texture_(0) {
-  // Allocate a CAContext to use to transport the CALayer to the browser
-  // process.
-  base::scoped_nsobject<NSDictionary> dict([[NSDictionary alloc] init]);
-  CGSConnectionID connection_id = CGSMainConnectionID();
-  context_.reset([CAContext contextWithCGSConnection:connection_id
-                                             options:dict]);
-  [context_ retain];
-}
+          fbo_texture_(0),
+          fbo_scale_factor_(1),
+          display_timeout_timer_(
+              FROM_HERE,
+              base::TimeDelta::FromSeconds(1) / 6,
+              this,
+              &CALayerStorageProvider::DisplayTimeoutFired) {}
 
 CALayerStorageProvider::~CALayerStorageProvider() {
 }
 
 gfx::Size CALayerStorageProvider::GetRoundedSize(gfx::Size size) {
   return size;
 }
 
 bool CALayerStorageProvider::AllocateColorBufferStorage(
     CGLContextObj context, GLuint texture,
@@ skipping 16 matching lines @@
   error = glGetError();
   if (error != GL_NO_ERROR) {
     DLOG(ERROR) << "glTexImage failed with GL error: " << error;
     return false;
   }
   glFlush();
 
   // Disable the fade-in animation as the layer is changed.
   ScopedCAActionDisabler disabler;
 
-  // Allocate a CALayer to draw texture into.
+  // Set the parameters that will be used to allocate the CALayer to draw the
+  // texture into.
   share_group_context_.reset(CGLRetainContext(context));
   fbo_texture_ = texture;
   fbo_pixel_size_ = pixel_size;
-  layer_.reset([[ImageTransportLayer alloc] initWithStorageProvider:this]);
-  gfx::Size dip_size(gfx::ToFlooredSize(gfx::ScaleSize(
-      fbo_pixel_size_, 1.0f / scale_factor)));
-  [layer_ setContentsScale:scale_factor];
-  [layer_ setFrame:CGRectMake(0, 0, dip_size.width(), dip_size.height())];
+  fbo_scale_factor_ = scale_factor;
   return true;
 }
 
 void CALayerStorageProvider::FreeColorBufferStorage() {
   // We shouldn't be asked to free a texture when we still have yet to draw it.
   DCHECK(!has_pending_draw_);
   has_pending_draw_ = false;
   can_draw_returned_false_count_ = 0;
 
   // Note that |context_| still holds a reference to |layer_|, and will until
   // a new frame is swapped in.
   [layer_ displayIfNeeded];
   [layer_ resetStorageProvider];
   layer_.reset();
 
   share_group_context_.reset();
   fbo_texture_ = 0;
   fbo_pixel_size_ = gfx::Size();
 }
 
-uint64 CALayerStorageProvider::GetSurfaceHandle() const {
+void CALayerStorageProvider::DiscardBackbuffer() {
+  // If this surface's backbuffer is discarded, it is because this surface has
+  // been made non-visible. Ensure that the previous contents are not briefly
+  // flashed when this is made visible by creating a new CALayer and CAContext
+  // at the next swap.
+  [layer_ resetStorageProvider];
+  layer_.reset();
+  context_.reset();
+}
+
+uint64 CALayerStorageProvider::SwapBuffersAndGetSurfaceHandle() {
+  DCHECK(!has_pending_draw_);
+  has_pending_draw_ = true;
+
+  // Allocate a CAContext to use to transport the CALayer to the browser
+  // process.
+  if (!context_) {
+    base::scoped_nsobject<NSDictionary> dict([[NSDictionary alloc] init]);
+    CGSConnectionID connection_id = CGSMainConnectionID();
+    context_.reset([CAContext contextWithCGSConnection:connection_id
+                                               options:dict]);
+    [context_ retain];
+  }
+
+  // Allocate a CALayer to use to draw the content.
+  if (!layer_) {
+    layer_.reset([[ImageTransportLayer alloc] initWithStorageProvider:this]);
+    gfx::Size dip_size(gfx::ToFlooredSize(gfx::ScaleSize(
+        fbo_pixel_size_, 1.0f / fbo_scale_factor_)));
+    [layer_ setContentsScale:fbo_scale_factor_];
+    [layer_ setFrame:CGRectMake(0, 0, dip_size.width(), dip_size.height())];
+
+    // Make the CALayer current to the CAContext and display its contents
+    // immediately.
+    [context_ setLayer:layer_];
+  }
+
+  // Tell CoreAnimation to draw our frame.
+  if (gpu_vsync_disabled_) {
+    [layer_ setNeedsDisplay];
+    [layer_ displayIfNeeded];
+    // Rapid setNeedsDisplay+displayIfNeeded calls are sometimes dropped,
+    // ensure forward progress by re-scheduling the command buffer immediately.
+    UnblockIfNeededAfterPendingFrameDrawn();
+  } else {
+   if (![layer_ isAsynchronous])
+     [layer_ setAsynchronous:YES];
+  }
+
+  // In case CoreAnimation drops the frame, or is lazy in actually drawing
+  // the frame, reset the timer to un-block this command buffer in the event
+  // of a timeout.
+  display_timeout_timer_.Reset();
+
   return SurfaceHandleFromCAContextID([context_ contextId]);
 }
 
-void CALayerStorageProvider::WillSwapBuffers() {
-  DCHECK(!has_pending_draw_);
-  has_pending_draw_ = true;
-
-  // Don't add the layer to the CAContext until a SwapBuffers is going to be
-  // called, because the texture does not have any content until the
-  // SwapBuffers call is about to be made.
-  if ([context_ layer] != layer_.get())
-    [context_ setLayer:layer_];
-
-  if (![layer_ isAsynchronous])
-    [layer_ setAsynchronous:YES];
-}
-
 void CALayerStorageProvider::CanFreeSwappedBuffer() {
 }
 
 CGLContextObj CALayerStorageProvider::LayerShareGroupContext() {
   return share_group_context_;
 }
 
 bool CALayerStorageProvider::LayerCanDraw() {
   if (has_pending_draw_) {
     can_draw_returned_false_count_ = 0;
     return true;
   } else {
-    if (can_draw_returned_false_count_ == 30) {
-      if ([layer_ isAsynchronous])
+    if ([layer_ isAsynchronous]) {
+      DCHECK(!gpu_vsync_disabled_);
+      // If we are in asynchronous mode, we will be getting callbacks at every
+      // vsync, asking us if we have anything to draw. If we get 30 of these in
+      // a row, ask that we stop getting these callback for now, so that we
+      // don't waste CPU cycles.
+      if (can_draw_returned_false_count_ == 30)
         [layer_ setAsynchronous:NO];
-    } else {
-      can_draw_returned_false_count_ += 1;
+      else
+        can_draw_returned_false_count_ += 1;
     }
     return false;
   }
 }
 
 void CALayerStorageProvider::LayerDoDraw() {
-  DCHECK(has_pending_draw_);
-  has_pending_draw_ = false;
-
   GLint viewport[4] = {0, 0, 0, 0};
   glGetIntegerv(GL_VIEWPORT, viewport);
   gfx::Size viewport_size(viewport[2], viewport[3]);
 
   // Set the coordinate system to be one-to-one with pixels.
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glOrtho(0, viewport_size.width(), 0, viewport_size.height(), -1, 1);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
@@ skipping 14 matching lines @@
     glVertex2f(fbo_pixel_size_.width(), fbo_pixel_size_.height());
 
     glTexCoord2f(fbo_pixel_size_.width(), 0);
     glVertex2f(fbo_pixel_size_.width(), 0);
   }
   glEnd();
   glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
   glDisable(GL_TEXTURE_RECTANGLE_ARB);
 
   // Allow forward progress in the context now that the swap is complete.
+  UnblockIfNeededAfterPendingFrameDrawn();
+}
+
+void CALayerStorageProvider::LayerResetStorageProvider() {
+  // If the command buffer has been unscheduled waiting for the draw, that draw
+  // will never come, so re-schedule the command buffer now.
+  UnblockIfNeededAfterPendingFrameDrawn();
+}
+
+void CALayerStorageProvider::DisplayTimeoutFired() {
+  if (!has_pending_draw_)
+    return;
+  if ([layer_ isAsynchronous])
+    [layer_ setAsynchronous:NO];
+  [layer_ displayIfNeeded];
+  UnblockIfNeededAfterPendingFrameDrawn();
+}
+
+void CALayerStorageProvider::UnblockIfNeededAfterPendingFrameDrawn() {
+  if (!has_pending_draw_)
+    return;
   transport_surface_->UnblockContextAfterPendingSwap();
+  has_pending_draw_ = false;
 }
 
 }  //  namespace content