Move logic from ImageTransportSurfaceOverlayMac into ui/

ui/accelerated_widget_mac/ca_renderer_layer_tree.mm

 // Copyright 2016 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 "ui/accelerated_widget_mac/ca_layer_tree_mac.h"
+#include "ui/accelerated_widget_mac/ca_renderer_layer_tree.h"
 
 #include <AVFoundation/AVFoundation.h>
 #include <CoreMedia/CoreMedia.h>
 #include <CoreVideo/CoreVideo.h>
 #include <GLES2/gl2extchromium.h>
 
 #include "base/command_line.h"
 #include "base/mac/sdk_forward_declarations.h"
 #include "base/trace_event/trace_event.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 104 matching lines @@
     LOG(ERROR) << "CVPixelBufferCreateWithIOSurface failed with " << cv_return;
     return false;
   }
 
   return AVSampleBufferDisplayLayerEnqueueCVPixelBuffer(av_layer,
                                                         cv_pixel_buffer);
 }
 
 }  // namespace
 
-CALayerTree::CALayerTree() {}
-CALayerTree::~CALayerTree() {}
+CARendererLayerTree::CARendererLayerTree() {}
+CARendererLayerTree::~CARendererLayerTree() {}
 
-bool CALayerTree::ScheduleCALayer(
+bool CARendererLayerTree::ScheduleCALayer(
     bool is_clipped,
     const gfx::Rect& clip_rect,
     unsigned sorting_context_id,
     const gfx::Transform& transform,
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
     base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer,
     const gfx::RectF& contents_rect,
     const gfx::Rect& rect,
     unsigned background_color,
     unsigned edge_aa_mask,
     float opacity) {
   // Excessive logging to debug white screens (crbug.com/583805).
   // TODO(ccameron): change this back to a DLOG.
   if (has_committed_) {
     LOG(ERROR) << "ScheduleCALayer called after CommitScheduledCALayers.";
     return false;
   }
   return root_layer_.AddContentLayer(is_clipped, clip_rect, sorting_context_id,
                                      transform, io_surface, cv_pixel_buffer,
                                      contents_rect, rect, background_color,
                                      edge_aa_mask, opacity);
 }
 
-void CALayerTree::CommitScheduledCALayers(CALayer* superlayer,
-                                          std::unique_ptr<CALayerTree> old_tree,
-                                          float scale_factor) {
-  TRACE_EVENT0("gpu", "CALayerTree::CommitScheduledCALayers");
+void CARendererLayerTree::CommitScheduledCALayers(
+    CALayer* superlayer,
+    std::unique_ptr<CARendererLayerTree> old_tree,
+    float scale_factor) {
+  TRACE_EVENT0("gpu", "CARendererLayerTree::CommitScheduledCALayers");
   RootLayer* old_root_layer = nullptr;
   if (old_tree) {
     DCHECK(old_tree->has_committed_);
     if (old_tree->scale_factor_ == scale_factor)
       old_root_layer = &old_tree->root_layer_;
   }
 
   root_layer_.CommitToCA(superlayer, old_root_layer, scale_factor);
   // If there are any extra CALayers in |old_tree| that were not stolen by this
   // tree, they will be removed from the CALayer tree in this deallocation.
   old_tree.reset();
   has_committed_ = true;
   scale_factor_ = scale_factor;
 }
 
-CALayerTree::RootLayer::RootLayer() {}
+CARendererLayerTree::RootLayer::RootLayer() {}
 
 // Note that for all destructors, the the CALayer will have been reset to nil if
 // another layer has taken it.
-CALayerTree::RootLayer::~RootLayer() {
+CARendererLayerTree::RootLayer::~RootLayer() {
   [ca_layer removeFromSuperlayer];
 }
 
-CALayerTree::ClipAndSortingLayer::ClipAndSortingLayer(
+CARendererLayerTree::ClipAndSortingLayer::ClipAndSortingLayer(
     bool is_clipped,
     gfx::Rect clip_rect,
     unsigned sorting_context_id,
     bool is_singleton_sorting_context)
     : is_clipped(is_clipped),
       clip_rect(clip_rect),
       sorting_context_id(sorting_context_id),
       is_singleton_sorting_context(is_singleton_sorting_context) {}
 
-CALayerTree::ClipAndSortingLayer::ClipAndSortingLayer(
+CARendererLayerTree::ClipAndSortingLayer::ClipAndSortingLayer(
     ClipAndSortingLayer&& layer)
     : transform_layers(std::move(layer.transform_layers)),
       is_clipped(layer.is_clipped),
       clip_rect(layer.clip_rect),
       sorting_context_id(layer.sorting_context_id),
-      is_singleton_sorting_context(
-          layer.is_singleton_sorting_context),
+      is_singleton_sorting_context(layer.is_singleton_sorting_context),
       ca_layer(layer.ca_layer) {
   // Ensure that the ca_layer be reset, so that when the destructor is called,
   // the layer hierarchy is unaffected.
   // TODO(ccameron): Add a move constructor for scoped_nsobject to do this
   // automatically.
   layer.ca_layer.reset();
 }
 
-CALayerTree::ClipAndSortingLayer::~ClipAndSortingLayer() {
+CARendererLayerTree::ClipAndSortingLayer::~ClipAndSortingLayer() {
   [ca_layer removeFromSuperlayer];
 }
 
-CALayerTree::TransformLayer::TransformLayer(const gfx::Transform& transform)
+CARendererLayerTree::TransformLayer::TransformLayer(
+    const gfx::Transform& transform)
     : transform(transform) {}
 
-CALayerTree::TransformLayer::TransformLayer(TransformLayer&& layer)
+CARendererLayerTree::TransformLayer::TransformLayer(TransformLayer&& layer)
     : transform(layer.transform),
       content_layers(std::move(layer.content_layers)),
       ca_layer(layer.ca_layer) {
   layer.ca_layer.reset();
 }
 
-CALayerTree::TransformLayer::~TransformLayer() {
+CARendererLayerTree::TransformLayer::~TransformLayer() {
   [ca_layer removeFromSuperlayer];
 }
 
-CALayerTree::ContentLayer::ContentLayer(
+CARendererLayerTree::ContentLayer::ContentLayer(
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
     base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer,
     const gfx::RectF& contents_rect,
     const gfx::Rect& rect,
     unsigned background_color,
     unsigned edge_aa_mask,
     float opacity)
     : io_surface(io_surface),
       cv_pixel_buffer(cv_pixel_buffer),
       contents_rect(contents_rect),
@@ skipping 31 matching lines @@
           kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange &&
       contents_rect == gfx::RectF(0, 0, 1, 1)) {
     // Enable only for hardware decoded frames, to see if flashing bugs are
     // particular to software IOSurfaces.
     // https://crbug.com/598269
     if (cv_pixel_buffer)
       use_av_layer = true;
   }
 }
 
-CALayerTree::ContentLayer::ContentLayer(ContentLayer&& layer)
+CARendererLayerTree::ContentLayer::ContentLayer(ContentLayer&& layer)
     : io_surface(layer.io_surface),
       cv_pixel_buffer(layer.cv_pixel_buffer),
       contents_rect(layer.contents_rect),
       rect(layer.rect),
       background_color(layer.background_color),
       ca_edge_aa_mask(layer.ca_edge_aa_mask),
       opacity(layer.opacity),
       ca_layer(std::move(layer.ca_layer)),
       av_layer(std::move(layer.av_layer)),
       use_av_layer(layer.use_av_layer) {
   DCHECK(!layer.ca_layer);
   DCHECK(!layer.av_layer);
 }
 
-CALayerTree::ContentLayer::~ContentLayer() {
+CARendererLayerTree::ContentLayer::~ContentLayer() {
   [ca_layer removeFromSuperlayer];
 }
 
-bool CALayerTree::RootLayer::AddContentLayer(
+bool CARendererLayerTree::RootLayer::AddContentLayer(
     bool is_clipped,
     const gfx::Rect& clip_rect,
     unsigned sorting_context_id,
     const gfx::Transform& transform,
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
     base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer,
     const gfx::RectF& contents_rect,
     const gfx::Rect& rect,
     unsigned background_color,
     unsigned edge_aa_mask,
@@ skipping 32 matching lines @@
     clip_and_sorting_layers.push_back(
         ClipAndSortingLayer(is_clipped, clip_rect, sorting_context_id,
                             is_singleton_sorting_context));
   }
   clip_and_sorting_layers.back().AddContentLayer(
       transform, io_surface, cv_pixel_buffer, contents_rect, rect,
       background_color, edge_aa_mask, opacity);
   return true;
 }
 
-void CALayerTree::ClipAndSortingLayer::AddContentLayer(
+void CARendererLayerTree::ClipAndSortingLayer::AddContentLayer(
     const gfx::Transform& transform,
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
     base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer,
     const gfx::RectF& contents_rect,
     const gfx::Rect& rect,
     unsigned background_color,
     unsigned edge_aa_mask,
     float opacity) {
   bool needs_new_transform_layer = true;
   if (!transform_layers.empty()) {
     const TransformLayer& current_layer = transform_layers.back();
     if (current_layer.transform == transform)
       needs_new_transform_layer = false;
   }
   if (needs_new_transform_layer)
     transform_layers.push_back(TransformLayer(transform));
   transform_layers.back().AddContentLayer(io_surface, cv_pixel_buffer,
                                           contents_rect, rect, background_color,
                                           edge_aa_mask, opacity);
 }
 
-void CALayerTree::TransformLayer::AddContentLayer(
+void CARendererLayerTree::TransformLayer::AddContentLayer(
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
     base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer,
     const gfx::RectF& contents_rect,
     const gfx::Rect& rect,
     unsigned background_color,
     unsigned edge_aa_mask,
     float opacity) {
   content_layers.push_back(ContentLayer(io_surface, cv_pixel_buffer,
                                         contents_rect, rect, background_color,
                                         edge_aa_mask, opacity));
 }
 
-void CALayerTree::RootLayer::CommitToCA(CALayer* superlayer,
-                                        RootLayer* old_layer,
-                                        float scale_factor) {
+void CARendererLayerTree::RootLayer::CommitToCA(CALayer* superlayer,
+                                                RootLayer* old_layer,
+                                                float scale_factor) {
   if (old_layer) {
     DCHECK(old_layer->ca_layer);
     std::swap(ca_layer, old_layer->ca_layer);
   } else {
     ca_layer.reset([[CALayer alloc] init]);
     [ca_layer setAnchorPoint:CGPointZero];
     [superlayer setSublayers:nil];
     [superlayer addSublayer:ca_layer];
     [superlayer setBorderWidth:0];
   }
   // Excessive logging to debug white screens (crbug.com/583805).
   // TODO(ccameron): change this back to a DCHECK.
   if ([ca_layer superlayer] != superlayer) {
-    LOG(ERROR) << "CALayerTree root layer not attached to tree.";
+    LOG(ERROR) << "CARendererLayerTree root layer not attached to tree.";
   }
 
   for (size_t i = 0; i < clip_and_sorting_layers.size(); ++i) {
     ClipAndSortingLayer* old_clip_and_sorting_layer = nullptr;
     if (old_layer && i < old_layer->clip_and_sorting_layers.size()) {
       old_clip_and_sorting_layer = &old_layer->clip_and_sorting_layers[i];
     }
     clip_and_sorting_layers[i].CommitToCA(
         ca_layer.get(), old_clip_and_sorting_layer, scale_factor);
   }
 }
 
-void CALayerTree::ClipAndSortingLayer::CommitToCA(
+void CARendererLayerTree::ClipAndSortingLayer::CommitToCA(
     CALayer* superlayer,
     ClipAndSortingLayer* old_layer,
     float scale_factor) {
   bool update_is_clipped = true;
   bool update_clip_rect = true;
   if (old_layer) {
     DCHECK(old_layer->ca_layer);
     std::swap(ca_layer, old_layer->ca_layer);
     update_is_clipped = old_layer->is_clipped != is_clipped;
     update_clip_rect = update_is_clipped || old_layer->clip_rect != clip_rect;
   } else {
     ca_layer.reset([[CALayer alloc] init]);
     [ca_layer setAnchorPoint:CGPointZero];
     [superlayer addSublayer:ca_layer];
   }
   // Excessive logging to debug white screens (crbug.com/583805).
   // TODO(ccameron): change this back to a DCHECK.
   if ([ca_layer superlayer] != superlayer) {
-    LOG(ERROR) << "CALayerTree root layer not attached to tree.";
+    LOG(ERROR) << "CARendererLayerTree root layer not attached to tree.";
   }
 
   if (update_is_clipped)
     [ca_layer setMasksToBounds:is_clipped];
 
   if (update_clip_rect) {
     if (is_clipped) {
       gfx::RectF dip_clip_rect = gfx::RectF(clip_rect);
       dip_clip_rect.Scale(1 / scale_factor);
       [ca_layer setPosition:CGPointMake(dip_clip_rect.x(), dip_clip_rect.y())];
@@ skipping 11 matching lines @@
 
   for (size_t i = 0; i < transform_layers.size(); ++i) {
     TransformLayer* old_transform_layer = nullptr;
     if (old_layer && i < old_layer->transform_layers.size())
       old_transform_layer = &old_layer->transform_layers[i];
     transform_layers[i].CommitToCA(ca_layer.get(), old_transform_layer,
                                    scale_factor);
   }
 }
 
-void CALayerTree::TransformLayer::CommitToCA(CALayer* superlayer,
-                                             TransformLayer* old_layer,
-                                             float scale_factor) {
+void CARendererLayerTree::TransformLayer::CommitToCA(CALayer* superlayer,
+                                                     TransformLayer* old_layer,
+                                                     float scale_factor) {
   bool update_transform = true;
   if (old_layer) {
     DCHECK(old_layer->ca_layer);
     std::swap(ca_layer, old_layer->ca_layer);
     update_transform = old_layer->transform != transform;
   } else {
     ca_layer.reset([[CATransformLayer alloc] init]);
     [superlayer addSublayer:ca_layer];
   }
   DCHECK_EQ([ca_layer superlayer], superlayer);
@@ skipping 12 matching lines @@
 
   for (size_t i = 0; i < content_layers.size(); ++i) {
     ContentLayer* old_content_layer = nullptr;
     if (old_layer && i < old_layer->content_layers.size())
       old_content_layer = &old_layer->content_layers[i];
     content_layers[i].CommitToCA(ca_layer.get(), old_content_layer,
                                  scale_factor);
   }
 }
 
-void CALayerTree::ContentLayer::CommitToCA(CALayer* superlayer,
-                                           ContentLayer* old_layer,
-                                           float scale_factor) {
+void CARendererLayerTree::ContentLayer::CommitToCA(CALayer* superlayer,
+                                                   ContentLayer* old_layer,
+                                                   float scale_factor) {
   bool update_contents = true;
   bool update_contents_rect = true;
   bool update_rect = true;
   bool update_background_color = true;
   bool update_ca_edge_aa_mask = true;
   bool update_opacity = true;
   if (old_layer && old_layer->use_av_layer == use_av_layer) {
     DCHECK(old_layer->ca_layer);
     std::swap(ca_layer, old_layer->ca_layer);
     std::swap(av_layer, old_layer->av_layer);
@@ skipping 74 matching lines @@
     } else {
       // Grey represents a CALayer that has not changed.
       color.reset(CGColorCreateGenericRGB(0, 0, 0, 0.1));
     }
     [ca_layer setBorderWidth:1];
     [ca_layer setBorderColor:color];
   }
 }
 
 }  // namespace ui