Do not dynamically call setLayer on RenderWidgetHostViewCocoa

content/browser/renderer_host/render_widget_host_view_mac.mm

 // Copyright (c) 2012 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/render_widget_host_view_mac.h"
 
 #import <objc/runtime.h>
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/basictypes.h"
@@ skipping 502 matching lines @@
     compositing_iosurface_.reset(CompositingIOSurfaceMac::Create());
     if (!compositing_iosurface_) {
       LOG(ERROR) << "Failed to create CompositingIOSurface";
       return false;
     }
   }
 
   return true;
 }
 
-void RenderWidgetHostViewMac::CreateSoftwareLayerAndDestroyCompositedLayer() {
-  TRACE_EVENT0(
-      "browser",
-      "RenderWidgetHostViewMac::CreateSoftwareLayerAndDestroyCompositedLayer");
-
+void RenderWidgetHostViewMac::CreateSoftwareLayer() {
+  TRACE_EVENT0("browser", "RenderWidgetHostViewMac::CreateSoftwareLayer");
   if (software_layer_ || !use_core_animation_)
     return;
 
   ScopedCAActionDisabler disabler;
 
   // Create the layer.
   software_layer_.reset([[SoftwareLayer alloc]
       initWithRenderWidgetHostViewMac:this]);
   if (!software_layer_) {
     LOG(ERROR) << "Failed to create CALayer for software rendering";
     return;
   }
 
-  // Make the layer current and get rid of the old layer, if there is one.
-  [cocoa_view_ setLayer:software_layer_];
-  DestroyCompositedIOSurfaceAndLayer(kDestroyContext);
+  // Make the layer visible.
+  [background_layer_ addSublayer:software_layer_];
 }
 
 void RenderWidgetHostViewMac::DestroySoftwareLayer() {
   if (!software_layer_)
     return;
 
   ScopedCAActionDisabler disabler;
-
-  if ([cocoa_view_ layer] == software_layer_.get())
-    [cocoa_view_ setLayer:background_layer_];
   [software_layer_ removeFromSuperlayer];
   [software_layer_ disableRendering];
   software_layer_.reset();
 }
 
-bool RenderWidgetHostViewMac::CreateCompositedLayerAndDestroySoftwareLayer() {
-  TRACE_EVENT0(
-      "browser",
-      "RenderWidgetHostViewMac::CreateCompositedLayerAndDestroySoftwareLayer");
-
+bool RenderWidgetHostViewMac::CreateCompositedIOSurfaceLayer() {
+  TRACE_EVENT0("browser",
+               "RenderWidgetHostViewMac::CreateCompositedIOSurfaceLayer");
   if (compositing_iosurface_layer_ || !use_core_animation_)
     return true;
 
   ScopedCAActionDisabler disabler;
 
   // Create the layer.
   compositing_iosurface_layer_.reset([[CompositingIOSurfaceLayer alloc]
       initWithRenderWidgetHostViewMac:this]);
   if (!compositing_iosurface_layer_) {
     LOG(ERROR) << "Failed to create CALayer for IOSurface";
     return false;
   }
 
-  // Make the layer current and get rid of the old layer, if there is one.
-  [cocoa_view_ setLayer:compositing_iosurface_layer_];
-  DestroySoftwareLayer();
+  // Make the layer visible.
+  [background_layer_ addSublayer:compositing_iosurface_layer_];
 
-  // Creating the CompositingIOSurfaceLayer may attempt to draw in setLayer,
-  // which, if it fails, will promptly tear down everything that was just
-  // created. If that happened, return failure.
+  // Creating the CompositingIOSurfaceLayer may attempt to draw inside
+  // addSublayer, which, if it fails, will promptly tear down everything that
+  // was just created. If that happened, return failure.
   return compositing_iosurface_layer_;
 }
 
+void RenderWidgetHostViewMac::DestroyCompositedIOSurfaceLayer() {
+  if (!compositing_iosurface_layer_)
+    return;
+
+  ScopedCAActionDisabler disabler;
+  [compositing_iosurface_layer_ removeFromSuperlayer];
+  [compositing_iosurface_layer_ disableCompositing];
+  compositing_iosurface_layer_.reset();
+}
+
 void RenderWidgetHostViewMac::DestroyCompositedIOSurfaceAndLayer(
     DestroyContextBehavior destroy_context_behavior) {
   // Any pending frames will not be displayed, so ack them now.
   SendPendingSwapAck();
 
-  ScopedCAActionDisabler disabler;
+  DestroyCompositedIOSurfaceLayer();
+  compositing_iosurface_.reset();
 
-  compositing_iosurface_.reset();
-  if (compositing_iosurface_layer_) {
-    if ([cocoa_view_ layer] == compositing_iosurface_layer_.get())
-      [cocoa_view_ setLayer:background_layer_];
-    [compositing_iosurface_layer_ removeFromSuperlayer];
-    [compositing_iosurface_layer_ disableCompositing];
-    compositing_iosurface_layer_.reset();
-  }
   switch (destroy_context_behavior) {
     case kLeaveContextBoundToView:
       break;
     case kDestroyContext:
       ClearBoundContextDrawable();
       compositing_iosurface_context_ = NULL;
       break;
     default:
       NOTREACHED();
       break;
@@ skipping 167 matching lines @@
   backing_store_scale_factor_ = new_scale_factor;
 
   BackingStoreMac* backing_store = static_cast<BackingStoreMac*>(
       render_widget_host_->GetBackingStore(false));
   if (backing_store)
     backing_store->ScaleFactorChanged(backing_store_scale_factor_);
 
   ScopedCAActionDisabler disabler;
 
   if (software_layer_) {
-    [software_layer_ disableRendering];
-    software_layer_.reset();
-    CreateSoftwareLayerAndDestroyCompositedLayer();
+    DestroySoftwareLayer();
+    CreateSoftwareLayer();
   }
 
   // Dynamically calling setContentsScale on a CAOpenGLLayer for which
   // setAsynchronous is dynamically toggled can result in flashes of corrupt
   // content. Work around this by replacing the entire layer when the scale
   // factor changes.
   if (compositing_iosurface_layer_) {
-    [compositing_iosurface_layer_ disableCompositing];
-    compositing_iosurface_layer_.reset();
-    CreateCompositedLayerAndDestroySoftwareLayer();
+    DestroyCompositedIOSurfaceLayer();
+    CreateCompositedIOSurfaceLayer();
   }
 
   render_widget_host_->NotifyScreenInfoChanged();
 }
 
 RenderWidgetHost* RenderWidgetHostViewMac::GetRenderWidgetHost() const {
   return render_widget_host_;
 }
 
 void RenderWidgetHostViewMac::WasShown() {
@@ skipping 668 matching lines @@
       compositing_iosurface_->CopyToVideoFrame(
           gfx::Rect(size), frame,
           base::Bind(callback, present_time));
       DCHECK_EQ(CGLGetCurrentContext(),
                 compositing_iosurface_context_->cgl_context());
     }
   }
 
   // Create the layer for the composited content only after the IOSurface has
   // been initialized.
-  if (!CreateCompositedLayerAndDestroySoftwareLayer()) {
+  if (!CreateCompositedIOSurfaceLayer()) {

[Ken Russell (switch to Gerrit), 2014/03/07 00:29:56]

Who takes care of deleting the software layer in this case?

[ccameron, 2014/03/07 07:30:01]

I moved this to where the software frame and backing store are removed at [1] in
GotAcceleratedFrame.

Once we remove the non-CoreAnimation and legacy-software code (maybe in 2
weeks?), I may in-line the GotSoftware/AcceleratedFrame code.

     LOG(ERROR) << "Failed to create CompositingIOSurface layer";
     GotAcceleratedCompositingError();
     return;
   }
 
   GotAcceleratedFrame();
 
   gfx::Size window_size(NSSizeToCGSize([cocoa_view_ frame].size));
   if (window_size.IsEmpty()) {
     // setNeedsDisplay will never display and we'll never ack if the window is
@@ skipping 477 matching lines @@
   SendVSyncParametersToRenderer();
   if (!last_frame_was_accelerated_) {
     last_frame_was_accelerated_ = true;
 
     if (!use_core_animation_) {
       // Need to wipe the software view with transparency to expose the GL
       // underlay. Invalidate the whole window to do that.
       [cocoa_view_ setNeedsDisplay:YES];
     }
 
-    // Delete software backingstore.
+    // Delete software backingstore and layer.
     BackingStoreManager::RemoveBackingStore(render_widget_host_);
     software_frame_manager_->DiscardCurrentFrame();
+    DestroySoftwareLayer();

[ccameron, 2014/03/07 07:30:01]

[1] from above.

   }
 }
 
 void RenderWidgetHostViewMac::GotSoftwareFrame() {
-  CreateSoftwareLayerAndDestroyCompositedLayer();
+  CreateSoftwareLayer();

[Ken Russell (switch to Gerrit), 2014/03/07 00:29:56]

Who takes care of deleting the composited IOSurface layer in this case?

[ccameron, 2014/03/07 07:30:01]

This is done further down in the if (last_frame_was_accelerated_) block's
DestroyCompositedIOSurfaceAndLayer.

   [software_layer_ setNeedsDisplay];
   SendVSyncParametersToRenderer();
 
   if (last_frame_was_accelerated_) {
     last_frame_was_accelerated_ = false;
 
     // If overlapping views are allowed, then don't unbind the context
     // from the view (that is, don't call clearDrawble -- just delete the
     // texture and IOSurface). Rather, let it sit behind the software frame
     // that will be put up in front. This will prevent transparent
@@ skipping 932 matching lines @@
     renderWidgetHostView_->render_widget_host_->SendScreenRects();
     renderWidgetHostView_->render_widget_host_->WasResized();
   }
 
   // This call is necessary to make the window wait for a new frame at the new
   // size to be available before the resize completes. Calling only
   // setLayerContentsRedrawPolicy:NSViewLayerContentsRedrawOnSetNeedsDisplay on
   // this is not sufficient.
   ScopedCAActionDisabler disabler;
   CGRect frame = NSRectToCGRect([renderWidgetHostView_->cocoa_view() bounds]);
-  [[self layer] setFrame:frame];
-  [[self layer] setNeedsDisplay];
+  [renderWidgetHostView_->software_layer_ setFrame:frame];
+  [renderWidgetHostView_->software_layer_ setNeedsDisplay];
+  [renderWidgetHostView_->compositing_iosurface_layer_ setFrame:frame];
+  [renderWidgetHostView_->compositing_iosurface_layer_ setNeedsDisplay];
 }
 
 - (void)callSetNeedsDisplayInRect {
   DCHECK([NSThread isMainThread]);
   DCHECK(renderWidgetHostView_->call_set_needs_display_in_rect_pending_);
   [self setNeedsDisplayInRect:renderWidgetHostView_->invalid_rect_];
   renderWidgetHostView_->call_set_needs_display_in_rect_pending_ = false;
   renderWidgetHostView_->invalid_rect_ = NSZeroRect;
 
-  [[self layer] setNeedsDisplay];
+  [renderWidgetHostView_->software_layer_ setNeedsDisplay];
+  [renderWidgetHostView_->compositing_iosurface_layer_ setNeedsDisplay];
 }
 
 // Fills with white the parts of the area to the right and bottom for |rect|
 // that intersect |damagedRect|.
 - (void)fillBottomRightRemainderOfRect:(gfx::Rect)rect
                              dirtyRect:(gfx::Rect)damagedRect
                              inContext:(CGContextRef)context {
   if (damagedRect.right() > rect.right()) {
     int x = std::max(rect.right(), damagedRect.x());
     int y = std::min(rect.bottom(), damagedRect.bottom());
@@ skipping 972 matching lines @@
     WebMouseEvent event;
     event.type = WebInputEvent::MouseUp;
     event.button = WebMouseEvent::ButtonLeft;
     renderWidgetHostView_->ForwardMouseEvent(event);
 
     hasOpenMouseDown_ = NO;
   }
 
   // Resize the view's layers to match the new window size.
   ScopedCAActionDisabler disabler;
-  [[self layer] setFrame:NSRectToCGRect([self bounds])];
+  [renderWidgetHostView_->software_layer_
+      setFrame:NSRectToCGRect([self bounds])];
+  [renderWidgetHostView_->compositing_iosurface_layer_
+      setFrame:NSRectToCGRect([self bounds])];
 }
 
 - (void)undo:(id)sender {
   if (renderWidgetHostView_->render_widget_host_->IsRenderView()) {
     static_cast<RenderViewHostImpl*>(
         renderWidgetHostView_->render_widget_host_)->Undo();
   }
 }
 
 - (void)redo:(id)sender {
@@ skipping 283 matching lines @@
                                    CGColorGetConstantColor(kCGColorWhite));
     CGContextFillRect(context, clipRect);
   }
 }
 
 - (void)disableRendering {
   renderWidgetHostView_ = NULL;
 }
 
 @end  // implementation SoftwareLayer