Clean up GPU back-pressure with remote CALayers

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"
@@ skipping 72 matching lines @@
 
 @end
 
 namespace content {
 
 CALayerStorageProvider::CALayerStorageProvider(
     ImageTransportSurfaceFBO* transport_surface)
         : transport_surface_(transport_surface),
           gpu_vsync_disabled_(CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kDisableGpuVsync)),
+          throttling_disabled_(false),
           has_pending_draw_(false),
+          pending_draw_weak_factory_(this),
           can_draw_returned_false_count_(0),
           fbo_texture_(0),
-          fbo_scale_factor_(1),
-          weak_factory_(this) {}
+          fbo_scale_factor_(1) {}
 
 CALayerStorageProvider::~CALayerStorageProvider() {
 }
 
 gfx::Size CALayerStorageProvider::GetRoundedSize(gfx::Size size) {
   return size;
 }
 
 bool CALayerStorageProvider::AllocateColorBufferStorage(
     CGLContextObj context, GLuint texture,
@@ skipping 26 matching lines @@
   // 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;
   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();
+  can_draw_returned_false_count_ = 0;
 }
 
 void CALayerStorageProvider::SwapBuffers(
     const gfx::Size& size, float scale_factor) {
   DCHECK(!has_pending_draw_);
   has_pending_draw_ = true;
 
   // Allocate a CAContext to use to transport the CALayer to the browser
   // process.
   if (!context_) {
@@ skipping 10 matching lines @@
     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. We will send the IPC to the browser
-  // when CoreAnimation has drawn our frame.
-  if (gpu_vsync_disabled_) {
-    DrawWithVsyncDisabled();
+  // Tell CoreAnimation to draw our frame.
+  if (gpu_vsync_disabled_ || throttling_disabled_) {
+    DrawImmediatelyAndUnblockBrowser();
   } else {
     if (![layer_ isAsynchronous])
       [layer_ setAsynchronous:YES];
+
+    // If CoreAnimation doesn't end up drawing our frame, un-block the browser
+    // after a timeout of 1/6th of a second has passed.
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&CALayerStorageProvider::DrawImmediatelyAndUnblockBrowser,
+                   pending_draw_weak_factory_.GetWeakPtr()),
+        base::TimeDelta::FromSeconds(1) / 6);
   }
 }
 
-void CALayerStorageProvider::DrawWithVsyncDisabled() {
-  DCHECK(has_pending_draw_);
+void CALayerStorageProvider::DrawImmediatelyAndUnblockBrowser() {
+  CHECK(has_pending_draw_);
+  if ([layer_ isAsynchronous])
+    [layer_ setAsynchronous:NO];
   [layer_ setNeedsDisplay];
+  [layer_ displayIfNeeded];
 
-  // 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));
-  }
+  // Sometimes, the setNeedsDisplay+displayIfNeeded pairs have no effect. This
+  // can happen if the NSView that this layer is attached to isn't in the
+  // window hierarchy (e.g, tab capture of a backgrounded tab). In this case,
+  // the frame will never be seen, so drop it.
+  UnblockBrowserIfNeeded();
 }
 
 void CALayerStorageProvider::WillWriteToBackbuffer() {
-  // TODO(ccameron): The browser may need to continue issuing swaps even when
-  // they do not draw. In these cases it is necessary to either double-buffer
-  // the resulting texture, or to drop frames.
+  // The browser will always throttle itself so that there is no pending draw
+  // when this output surface is written to.
+  DCHECK(!has_pending_draw_);
 }
 
 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() {
+void CALayerStorageProvider::SwapBuffersAckedByBrowser(
+    bool disable_throttling) {
+  throttling_disabled_ = disable_throttling;
 }
 
 CGLContextObj CALayerStorageProvider::LayerShareGroupContext() {
   return share_group_context_;
 }
 
 bool CALayerStorageProvider::LayerCanDraw() {
   if (has_pending_draw_) {
     can_draw_returned_false_count_ = 0;
     return true;
@@ skipping 41 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.
-  DCHECK(has_pending_draw_);
-  SendPendingSwapToBrowserAfterFrameDrawn();
+  UnblockBrowserIfNeeded();
 }
 
 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();
+  UnblockBrowserIfNeeded();
 }
 
-void CALayerStorageProvider::SendPendingSwapToBrowserAfterFrameDrawn() {
+void CALayerStorageProvider::UnblockBrowserIfNeeded() {
   if (!has_pending_draw_)
     return;
-  weak_factory_.InvalidateWeakPtrs();
+  pending_draw_weak_factory_.InvalidateWeakPtrs();
   has_pending_draw_ = false;
   transport_surface_->SendSwapBuffers(
       SurfaceHandleFromCAContextID([context_ contextId]),
       fbo_pixel_size_,
       fbo_scale_factor_);
 }
 
 }  //  namespace content