Dynamically set CAOpenGLLAyer to be asynchronous

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/sdk_forward_declarations.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_mac.h"
 #include "content/browser/renderer_host/compositing_iosurface_context_mac.h"
 #include "content/browser/renderer_host/compositing_iosurface_mac.h"
 #include "ui/base/cocoa/animation_utils.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gl/gpu_switching_manager.h"
 
 @implementation CompositingIOSurfaceLayer
 
 @synthesize context = context_;
 
 - (id)initWithRenderWidgetHostViewMac:(content::RenderWidgetHostViewMac*)r {
   if (self = [super init]) {
     renderWidgetHostView_ = r;
     context_ = content::CompositingIOSurfaceContext::Get(
         content::CompositingIOSurfaceContext::kOffscreenContextWindowNumber);
     DCHECK(context_);
+    needsDisplay_ = NO;
 
     ScopedCAActionDisabler disabler;
     [self setBackgroundColor:CGColorGetConstantColor(kCGColorWhite)];
     [self setContentsGravity:kCAGravityTopLeft];
     [self setFrame:NSRectToCGRect(
         [renderWidgetHostView_->cocoa_view() bounds])];
     [self setNeedsDisplay];
     [self updateScaleFactor];
   }
   return self;
@@ skipping 18 matching lines @@
   ScopedCAActionDisabler disabler;
   [self setContentsScale:new_scale_factor];
 }
 
 - (void)disableCompositing{
   ScopedCAActionDisabler disabler;
   [self removeFromSuperlayer];
   renderWidgetHostView_ = nil;
 }
 
+- (void)gotNewFrame {
+  if (![self isAsynchronous]) {
+    [self setNeedsDisplay];
+    [self setAsynchronous:YES];
+  } else {
+    needsDisplay_ = YES;
+  }
+}
+
+- (void)timerSinceGotNewFrameFired {
+  if (![self isAsynchronous])
+    return;
+
+  [self setAsynchronous:NO];
+  if (needsDisplay_)
+    [self setNeedsDisplay];
+}
+
 // 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_)
     return [super copyCGLContextForPixelFormat:pixelFormat];
   return CGLRetainContext(context_->cgl_context());
 }
 
+- (void)setNeedsDisplay {
+  needsDisplay_ = YES;
+  [super setNeedsDisplay];
+}
+
+- (BOOL)canDrawInCGLContext:(CGLContextObj)glContext
+                pixelFormat:(CGLPixelFormatObj)pixelFormat
+               forLayerTime:(CFTimeInterval)timeInterval
+                displayTime:(const CVTimeStamp*)timeStamp {
+  return needsDisplay_;
+}
+
 - (void)drawInCGLContext:(CGLContextObj)glContext
              pixelFormat:(CGLPixelFormatObj)pixelFormat
             forLayerTime:(CFTimeInterval)timeInterval
              displayTime:(const CVTimeStamp*)timeStamp {
   TRACE_EVENT0("browser", "CompositingIOSurfaceLayer::drawInCGLContext");
 
   if (!context_ ||
       (context_ && context_->cgl_context() != glContext) ||
       !renderWidgetHostView_ ||
       !renderWidgetHostView_->compositing_iosurface_) {
@@ skipping 45 matching lines @@
 
   if (!renderWidgetHostView_->compositing_iosurface_->DrawIOSurface(
         context_,
         window_rect,
         window_scale_factor,
         false)) {
     renderWidgetHostView_->GotAcceleratedCompositingError();
     return;
   }
 
+  needsDisplay_ = NO;
   renderWidgetHostView_->SendPendingLatencyInfoToHost();
 }
 
 @end