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),
+          weak_factory_(this) {}
 
 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 {
-  return SurfaceHandleFromCAContextID([context_ contextId]);
-}
-
-void CALayerStorageProvider::WillSwapBuffers() {
+void CALayerStorageProvider::SwapBuffers(
+    const gfx::Size& size, float scale_factor) {
   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())
+  // 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_];
+  }
 
-  if (![layer_ isAsynchronous])
-    [layer_ setAsynchronous:YES];
+  // Tell CoreAnimation to draw our frame. We will send the IPC to the browser
+  // when CoreAnimation has drawn our frame.
+  if (gpu_vsync_disabled_) {
+    DrawWithVsyncDisabled();
+  } else {
+    if (![layer_ isAsynchronous])
+      [layer_ setAsynchronous:YES];
+  }
 }
 
-void CALayerStorageProvider::CanFreeSwappedBuffer() {
+void CALayerStorageProvider::DrawWithVsyncDisabled() {
+  CHECK(has_pending_draw_);

[piman, 2014/08/27 21:21:42]

nit: DCHECK.

[ccameron, 2014/08/27 21:41:55]

Done.

+  [layer_ setNeedsDisplay];
+
+  // Sometimes, setNeedsDisplay calls are dropped on the floor. Make this not
+  // hang the renderer by re-issuing the call if the draw has not yet
+  // happened.
+  if (has_pending_draw_) {
+    // Delay sending another draw immediately to avoid starving the run loop.
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&CALayerStorageProvider::DrawWithVsyncDisabled,
+                   weak_factory_.GetWeakPtr()),
+        base::TimeDelta::FromMilliseconds(5));
+  }
+}
+
+void CALayerStorageProvider::WillWriteToBackbuffer() {
+  // The browser will throttle composites to avoid writing to the framebuffer
+  // before it has been drawn.
+  CHECK(!has_pending_draw_);

[piman, 2014/08/27 21:21:42]

nit: DCHECK.

Can you walk me through the entire logic? Because the GPU works asynchronously,
it feels racy to rely on what happens on the browser...

If there is a frame in flight at the time the view goes offscreen, can't that
mean that CA will stop issuing draws anyway? When the in-flight frame comes in,
won't we trigger this CHECK?

[ccameron, 2014/08/27 21:41:56]

I've removed this CHECK and changed it to a TODO for reasons I'll get to in the
second half of this.

As written, the sequence of events is:
- The compositor draws a frame and issues a swap. It will not produce another
frame until the swap is acknowledged via an IPC from the GPU process (the
GpuHostMsg_AcceleratedSurfaceBuffersSwapped IPC).
- The swap hits the GPU process, where we say "setNeedsDisplay" on the CALayer
- Some time later, potentially never (*), this setNeedsDisplay results in a
frame being drawn.
- After the frame is drawn, we send the IPC to the browser saying "hey,
compositor, you can get back to producing frames now"
- When the browser gets this IPC, it may produce more frames.

This relies on the fact that we know and trust that the browser won't request
any swaps (or anything else, for that matter) until after it receives the
GpuHostMsg_AcceleratedSurfaceBuffersSwapped IPC, we can be fairly certain that
this won't hit any issues.

Now, at the (*), we have an issue. If the view is offscreen and we still want to
get more frames (e.g, tab-casting), we will need to break this promise. I'm
working on a follow-up patch that will, in the WillWriteToBackbuffer call, make
a copy of the finished framebuffer texture (to present if needed), and allow the
compositor to continue forward producing frames.

[piman, 2014/08/27 22:13:05]

OK, so we rely on the fact that the only user of this is the browser compositor,
that (on mac) strictly uses max_frames == 1.

Note, you don't need to copy the existing framebuffer texture, you just need to
allocate a new one for the new frame.

+}
+
+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();
+}
+
+void CALayerStorageProvider::SwapBuffersAckedByBrowser() {
 }
 
 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.
-  transport_surface_->UnblockContextAfterPendingSwap();
+  DCHECK(has_pending_draw_);
+  SendPendingSwapToBrowserAfterFrameDrawn();
+}
+
+void CALayerStorageProvider::LayerResetStorageProvider() {
+  // If we are providing back-pressure by waiting for a draw, that draw will
+  // now never come, so release the pressure now.
+  SendPendingSwapToBrowserAfterFrameDrawn();
+}
+
+void CALayerStorageProvider::SendPendingSwapToBrowserAfterFrameDrawn() {
+  if (!has_pending_draw_)
+    return;
+  weak_factory_.InvalidateWeakPtrs();
+  has_pending_draw_ = false;
+  transport_surface_->SendSwapBuffers(
+      SurfaceHandleFromCAContextID([context_ contextId]),
+      fbo_pixel_size_,
+      fbo_scale_factor_);
 }
 
 }  //  namespace content