Simplify IOSurface CoreAnimation code: Part 1

content/browser/compositor/browser_compositor_view_private_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_private_mac.h"
 
 #include <map>
 
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "content/browser/compositor/gpu_process_transport_factory.h"
-#include "content/browser/renderer_host/compositing_iosurface_context_mac.h"
-#include "content/browser/renderer_host/compositing_iosurface_mac.h"
+#include "content/browser/compositor/io_surface_layer_mac.h"
+#include "content/browser/compositor/software_layer_mac.h"
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/render_widget_resize_helper.h"
-#include "content/browser/renderer_host/software_layer_mac.h"
 #include "content/common/gpu/surface_handle_types_mac.h"
 #include "content/public/browser/context_factory.h"
 #include "ui/base/cocoa/animation_utils.h"
 #include "ui/gl/scoped_cgl.h"
 
 namespace content {
 namespace {
 
 typedef std::map<gfx::AcceleratedWidget,BrowserCompositorViewMacInternal*>
     WidgetToInternalsMap;
@@ skipping 78 matching lines @@
   client_ = NULL;
 }
 
 bool BrowserCompositorViewMacInternal::HasFrameOfSize(
     const gfx::Size& dip_size) const {
   return last_swap_size_dip_ == dip_size;
 }
 
 int BrowserCompositorViewMacInternal::GetRendererID() const {
   if (io_surface_layer_)
-    return [io_surface_layer_ iosurface]->GetRendererID();
+    return [io_surface_layer_ rendererID];
   return 0;
 }
 
 void BrowserCompositorViewMacInternal::BeginPumpingFrames() {
   [io_surface_layer_ beginPumpingFrames];
 }
 
 void BrowserCompositorViewMacInternal::EndPumpingFrames() {
   [io_surface_layer_ endPumpingFrames];
 }
 
 void BrowserCompositorViewMacInternal::GotAcceleratedFrame(
     uint64 surface_handle, int output_surface_id,
     const std::vector<ui::LatencyInfo>& latency_info,
     gfx::Size pixel_size, float scale_factor) {
   // Record the surface and latency info to use when acknowledging this frame.
   DCHECK(!accelerated_output_surface_id_);
   accelerated_output_surface_id_ = output_surface_id;
   accelerated_latency_info_.insert(accelerated_latency_info_.end(),
                                    latency_info.begin(), latency_info.end());
 
   // If there is no client and therefore no superview to draw into, early-out.
   if (!client_) {
-    AcceleratedLayerDidDrawFrame();
+    IOSurfaceLayerDidDrawFrame();
     return;
   }
 
   // Disable the fade-in or fade-out effect if we create or remove layers.
   ScopedCAActionDisabler disabler;
 
   last_swap_size_dip_ = ConvertSizeToDIP(scale_factor, pixel_size);
   switch (GetSurfaceHandleType(surface_handle)) {
     case kSurfaceHandleTypeIOSurface: {
       IOSurfaceID io_surface_id = IOSurfaceIDFromSurfaceHandle(surface_handle);
@@ skipping 25 matching lines @@
   if ([ca_context_layer_ contextId] != ca_context_id) {
     ca_context_layer_.reset([[CALayerHost alloc] init]);
     [ca_context_layer_ setContextId:ca_context_id];
     [ca_context_layer_
         setAutoresizingMask:kCALayerMaxXMargin|kCALayerMaxYMargin];
     [flipped_layer_ addSublayer:ca_context_layer_];
   }
 
   // Acknowledge the frame to unblock the compositor immediately (the GPU
   // process will do any required throttling).
-  AcceleratedLayerDidDrawFrame();
+  IOSurfaceLayerDidDrawFrame();
 
   // If this replacing a same-type layer, remove it now that the new layer is
   // in the hierarchy.
   if (old_ca_context_layer != ca_context_layer_)
     DestroyCAContextLayer(old_ca_context_layer);
 
   // Remove any different-type layers that this is replacing.
   DestroyIOSurfaceLayer(io_surface_layer_);
   DestroySoftwareLayer();
 }
 
 void BrowserCompositorViewMacInternal::GotAcceleratedIOSurfaceFrame(
     IOSurfaceID io_surface_id,
     gfx::Size pixel_size,
     float scale_factor) {
   // In the layer is replaced, keep the old one around until after the new one
   // is installed to avoid flashes.
-  base::scoped_nsobject<CompositingIOSurfaceLayer> old_io_surface_layer =
+  base::scoped_nsobject<IOSurfaceLayer> old_io_surface_layer =
       io_surface_layer_;
 
   // Create or re-create an IOSurface layer if needed. If there already exists
   // a layer but it has the wrong scale factor or it was poisoned, re-create the
   // layer.
   bool needs_new_layer =
       !io_surface_layer_ ||
-      [io_surface_layer_ context]->HasBeenPoisoned() ||
-      [io_surface_layer_ iosurface]->scale_factor() != scale_factor;
+      [io_surface_layer_ hasBeenPoisoned] ||
+      [io_surface_layer_ scaleFactor] != scale_factor;
   if (needs_new_layer) {
-    scoped_refptr<content::CompositingIOSurfaceMac> iosurface =
-        content::CompositingIOSurfaceMac::Create();
-    if (!iosurface) {
-      LOG(ERROR) << "Failed to create CompositingIOSurfaceMac";
-    } else {
-      io_surface_layer_.reset([[CompositingIOSurfaceLayer alloc]
-          initWithIOSurface:iosurface
-            withScaleFactor:scale_factor
-                 withClient:this]);
-      if (io_surface_layer_)
-        [flipped_layer_ addSublayer:io_surface_layer_];
-      else
-        LOG(ERROR) << "Failed to create CompositingIOSurfaceLayer";
-    }
+    io_surface_layer_.reset(
+        [[IOSurfaceLayer alloc] initWithClient:this
+                               withScaleFactor:scale_factor]);
+    if (io_surface_layer_)
+      [flipped_layer_ addSublayer:io_surface_layer_];
+    else
+      LOG(ERROR) << "Failed to create IOSurfaceLayer";
   }
 
   // Open the provided IOSurface.
   if (io_surface_layer_) {
-    bool result = true;
-    gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
-        [io_surface_layer_ context]->cgl_context());
-    result = [io_surface_layer_ iosurface]->SetIOSurfaceWithContextCurrent(
-        [io_surface_layer_ context], io_surface_id, pixel_size, scale_factor);
+    bool result = [io_surface_layer_ gotFrameWithIOSurface:io_surface_id
+                                             withPixelSize:pixel_size
+                                           withScaleFactor:scale_factor];
     if (!result) {
       DestroyIOSurfaceLayer(io_surface_layer_);
-      LOG(ERROR) << "Failed open IOSurface in CompositingIOSurfaceLayer";
+      LOG(ERROR) << "Failed open IOSurface in IOSurfaceLayer";
     }
   }
 
   // Give a final complaint if anything with the layer's creation went wrong.
   // This frame will appear blank, the compositor will try to create another,
   // and maybe that will go better.
   if (!io_surface_layer_) {
-    LOG(ERROR) << "CompositingIOSurfaceLayer is nil, tab will be blank";
-    AcceleratedLayerHitError();
+    LOG(ERROR) << "IOSurfaceLayer is nil, tab will be blank";
+    IOSurfaceLayerHitError();
   }
 
   // Make the CALayer draw and set its size appropriately.
   if (io_surface_layer_) {
     [io_surface_layer_ gotNewFrame];
 
     // Set the bounds of the accelerated layer to match the size of the frame.
     // If the bounds changed, force the content to be displayed immediately.
     CGRect new_layer_bounds = CGRectMake(
         0, 0, last_swap_size_dip_.width(), last_swap_size_dip_.height());
@@ skipping 49 matching lines @@
 void BrowserCompositorViewMacInternal::DestroyCAContextLayer(
     base::scoped_nsobject<CALayerHost> ca_context_layer) {
   if (!ca_context_layer)
     return;
   [ca_context_layer removeFromSuperlayer];
   if (ca_context_layer == ca_context_layer_)
     ca_context_layer_.reset();
 }
 
 void BrowserCompositorViewMacInternal::DestroyIOSurfaceLayer(
-    base::scoped_nsobject<CompositingIOSurfaceLayer> io_surface_layer) {
+    base::scoped_nsobject<IOSurfaceLayer> io_surface_layer) {
   if (!io_surface_layer)
     return;
   [io_surface_layer resetClient];
   [io_surface_layer removeFromSuperlayer];
   if (io_surface_layer == io_surface_layer_)
     io_surface_layer_.reset();
 }
 
 void BrowserCompositorViewMacInternal::DestroySoftwareLayer() {
   if (!software_layer_)
     return;
   [software_layer_ removeFromSuperlayer];
   software_layer_.reset();
 }
 
-bool BrowserCompositorViewMacInternal::AcceleratedLayerShouldAckImmediately()
+bool BrowserCompositorViewMacInternal::IOSurfaceLayerShouldAckImmediately()
     const {
   // If there is no client then the accelerated layer is not in the hierarchy
   // and will never draw.
   if (!client_)
     return true;
   return client_->BrowserCompositorViewShouldAckImmediately();
 }
 
-void BrowserCompositorViewMacInternal::AcceleratedLayerDidDrawFrame() {
+void BrowserCompositorViewMacInternal::IOSurfaceLayerDidDrawFrame() {
   if (accelerated_output_surface_id_) {
     content::ImageTransportFactory::GetInstance()->OnSurfaceDisplayed(
         accelerated_output_surface_id_);
     accelerated_output_surface_id_ = 0;
   }
 
   if (client_)
     client_->BrowserCompositorViewFrameSwapped(accelerated_latency_info_);
 
   accelerated_latency_info_.clear();
 }
 
-void BrowserCompositorViewMacInternal::AcceleratedLayerHitError() {
+void BrowserCompositorViewMacInternal::IOSurfaceLayerHitError() {
   // Perform all acks that would have been done if the frame had succeeded, to
   // un-block the compositor and renderer.
-  AcceleratedLayerDidDrawFrame();
+  IOSurfaceLayerDidDrawFrame();
 
   // Poison the context being used and request a mulligan.
-  if (io_surface_layer_)
-    [io_surface_layer_ context]->PoisonContextAndSharegroup();
+  [io_surface_layer_ poisonContextAndSharegroup];
   compositor_->ScheduleFullRedraw();
 }
 
 // static
 BrowserCompositorViewMacInternal* BrowserCompositorViewMacInternal::
     FromAcceleratedWidget(gfx::AcceleratedWidget widget) {
   WidgetToInternalsMap::const_iterator found =
       g_widget_to_internals_map.Pointer()->find(widget);
   // This can end up being accessed after the underlying widget has been
   // destroyed, but while the ui::Compositor is still being destroyed.
   // Return NULL in these cases.
   if (found == g_widget_to_internals_map.Pointer()->end())
     return NULL;
   return found->second;
 }
 
 }  // namespace content