Mac ÜC: Enable GPU back-pressure from the browser to the renderer

content/browser/compositor/browser_compositor_view_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/browser/compositor/browser_compositor_view_mac.h"
 
 #include "base/debug/trace_event.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "content/browser/renderer_host/compositing_iosurface_context_mac.h"
 #include "content/browser/renderer_host/compositing_iosurface_mac.h"
 #include "content/browser/renderer_host/software_layer_mac.h"
 #include "content/public/browser/context_factory.h"
 #include "ui/base/cocoa/animation_utils.h"
 #include "ui/gl/scoped_cgl.h"
 
+@interface BrowserCompositorViewMac (Private)
+- (void)layerDidDrawFrame;
+- (void)gotAcceleratedLayerError;
+@end  // BrowserCompositorViewMac (Private)
+
+namespace content {
+
+// The CompositingIOSurfaceLayerClient interface needs to be implemented as a
+// C++ class to operate on, rather than Objective C class. This helper class
+// provides a bridge between the two.
+class BrowserCompositorViewMacHelper : public CompositingIOSurfaceLayerClient {
+ public:
+  BrowserCompositorViewMacHelper(BrowserCompositorViewMac* view)
+      : view_(view) {}
+  virtual ~BrowserCompositorViewMacHelper() {}
+
+ private:
+  // CompositingIOSurfaceLayerClient implementation:
+  virtual void AcceleratedLayerDidDrawFrame(bool succeeded) OVERRIDE {
+    [view_ layerDidDrawFrame];
+    if (!succeeded)
+      [view_ gotAcceleratedLayerError];
+  }
+
+  BrowserCompositorViewMac* view_;
+};
+
+}  // namespace content
+
+
 // The default implementation of additions to the NSView interface for browser
 // compositing should never be called. Log an error if they are.
 @implementation NSView (BrowserCompositorView)
 
 - (void)gotAcceleratedIOSurfaceFrame:(uint64)surface_handle
                        withPixelSize:(gfx::Size)pixel_size
                      withScaleFactor:(float)scale_factor {
   DLOG(ERROR) << "-[NSView gotAcceleratedIOSurfaceFrame] called on "
               << "non-overriden class.";
 }
 
 - (void)gotSoftwareFrame:(cc::SoftwareFrameData*)frame_data
          withScaleFactor:(float)scale_factor
               withCanvas:(SkCanvas*)canvas {
   DLOG(ERROR) << "-[NSView gotSoftwareFrame] called on non-overridden class.";
 }
 
 @end  // NSView (BrowserCompositorView)
 
 @implementation BrowserCompositorViewMac : NSView
 
-- (id)initWithSuperview:(NSView*)view {
+- (id)initWithSuperview:(NSView*)view
+             withClient:(content::BrowserCompositorViewMacClient*)client {
   if (self = [super init]) {
+    client_ = client;
+    helper_.reset(new content::BrowserCompositorViewMacHelper(self));
+
     // Disable the fade-in animation as the layer and view are added.
     ScopedCAActionDisabler disabler;
 
     // Make this view host a transparent layer.
     background_layer_.reset([[CALayer alloc] init]);
     [background_layer_ setContentsGravity:kCAGravityTopLeft];
     [self setLayer:background_layer_];
     [self setWantsLayer:YES];
 
     compositor_.reset(new ui::Compositor(self, content::GetContextFactory()));
     [view addSubview:self];
   }
   return self;
 }
 
+- (void)gotAcceleratedLayerError {
+  if (!accelerated_layer_)
+    return;
+
+  [accelerated_layer_ context]->PoisonContextAndSharegroup();
+  compositor_->ScheduleFullRedraw();
+}
+
 // This function closely mirrors RenderWidgetHostViewMac::LayoutLayers. When
 // only delegated rendering is supported, only one copy of this code will
 // need to exist.
 - (void)layoutLayers {
   // Disable animation of the layers' resizing or repositioning.
   ScopedCAActionDisabler disabler;
 
   NSSize superview_frame_size = [[self superview] frame].size;
   [self setFrame:NSMakeRect(
       0, 0, superview_frame_size.width, superview_frame_size.height)];
@@ skipping 26 matching lines @@
       [accelerated_layer_ displayIfNeeded];
     }
   }
 
   // The content area of the software layer is the size of the image provided.
   // Make the bounds of the layer match the superview's bounds, to ensure that
   // the visible contents are drawn.
   [software_layer_ setBounds:new_background_frame];
 }
 
+- (void)resetClient {
+  [accelerated_layer_ resetClient];
+  client_ = NULL;
+}
+
 - (ui::Compositor*)compositor {
   return compositor_.get();
 }
 
 - (void)gotAcceleratedIOSurfaceFrame:(uint64)surface_handle
                        withPixelSize:(gfx::Size)pixel_size
                      withScaleFactor:(float)scale_factor {
   ScopedCAActionDisabler disabler;
 
   // If there is already an accelerated layer, but it has the wrong scale
   // factor or it was poisoned, remove the old layer and replace it.
   base::scoped_nsobject<CompositingIOSurfaceLayer> old_accelerated_layer;
   if (accelerated_layer_ && (
           [accelerated_layer_ context]->HasBeenPoisoned() ||
           [accelerated_layer_ iosurface]->scale_factor() != scale_factor)) {
     old_accelerated_layer = accelerated_layer_;
     accelerated_layer_.reset();
   }
 
   // If there is not a layer for accelerated frames, create one.
   if (!accelerated_layer_) {
     // Disable the fade-in animation as the layer is added.
     ScopedCAActionDisabler disabler;
     scoped_refptr<content::CompositingIOSurfaceMac> iosurface =
         content::CompositingIOSurfaceMac::Create();
     accelerated_layer_.reset([[CompositingIOSurfaceLayer alloc]
         initWithIOSurface:iosurface
           withScaleFactor:scale_factor
-               withClient:NULL]);
+               withClient:helper_.get()]);
     [[self layer] addSublayer:accelerated_layer_];
   }
 
   {
     bool result = true;
     gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
         [accelerated_layer_ context]->cgl_context());
     result = [accelerated_layer_ iosurface]->SetIOSurfaceWithContextCurrent(
         [accelerated_layer_ context], surface_handle, pixel_size, scale_factor);
     if (!result)
@@ skipping 38 matching lines @@
   [self layoutLayers];
 
   // If there was an accelerated layer, remove it.
   // Disable the fade-out animation as the layer is removed.
   {
     ScopedCAActionDisabler disabler;
     [accelerated_layer_ resetClient];
     [accelerated_layer_ removeFromSuperlayer];
     accelerated_layer_.reset();
   }
+
+  // This call can be nested insider ui::Compositor commit calls, and can also
+  // make additional ui::Compositor commit calls. Avoid the potential recursion
+  // by acknowledging the frame asynchronously.
+  [self performSelector:@selector(layerDidDrawFrame)
+             withObject:nil
+             afterDelay:0];
+}
+
+- (void)layerDidDrawFrame {
+  if (client_)
+    client_->BrowserCompositorDidDrawFrame();
 }
 
 @end  // BrowserCompositorViewMac