Move logic from ImageTransportSurfaceOverlayMac into ui/

ui/accelerated_widget_mac/gl_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_partial_damage_tree_mac.h"
+#include "ui/accelerated_widget_mac/gl_renderer_layer_tree.h"
 
 #include "base/command_line.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/mac/sdk_forward_declarations.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/gfx/transform.h"
 
 @interface CALayer(Private)
 -(void)setContentsChanged;
 @end
 
 namespace ui {
 namespace {
 
 // When selecting a CALayer to re-use for partial damage, this is the maximum
 // fraction of the merged layer's pixels that may be not-updated by the swap
 // before we consider the CALayer to not be a good enough match, and create a
 // new one.
 const float kMaximumPartialDamageWasteFraction = 1.2f;
 
 // The maximum number of partial damage layers that may be created before we
 // give up and remove them all (doing full damage in the process).
 const size_t kMaximumPartialDamageLayers = 8;
 
 }  // namespace
 
-class CALayerPartialDamageTree::OverlayPlane {
+class GLRendererLayerTree::OverlayPlane {
  public:
   OverlayPlane(base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
                const gfx::Rect& pixel_frame_rect,
                const gfx::RectF& contents_rect)
       : io_surface(io_surface),
         contents_rect(contents_rect),
         pixel_frame_rect(pixel_frame_rect),
         layer_needs_update(true) {}
 
   ~OverlayPlane() {
@@ skipping 48 matching lines @@
       }
       [ca_layer setBorderWidth:1];
       [ca_layer setBorderColor:color];
     }
     layer_needs_update = false;
   }
 
  private:
 };
 
-void CALayerPartialDamageTree::UpdatePartialDamagePlanes(
-    CALayerPartialDamageTree* old_tree,
+void GLRendererLayerTree::UpdatePartialDamagePlanes(
+    GLRendererLayerTree* old_tree,
     const gfx::Rect& pixel_damage_rect) {
   // Don't create partial damage layers if partial swap is disabled.
   if (!allow_partial_swap_)
     return;
   // Only create partial damage layers when building on top of an existing tree.
   if (!old_tree)
     return;
   // If the frame size has changed, discard all of the old partial damage
   // layers.
   if (old_tree->root_plane_->pixel_frame_rect != root_plane_->pixel_frame_rect)
@@ skipping 85 matching lines @@
     }
     if (!old_plane_covered_by_swap) {
       DCHECK(old_plane->ca_layer);
       partial_damage_planes_.push_back(std::move(old_plane));
     }
   }
 
   partial_damage_planes_.push_back(std::move(plane_for_swap));
 }
 
-void CALayerPartialDamageTree::UpdateRootAndPartialDamagePlanes(
-    std::unique_ptr<CALayerPartialDamageTree> old_tree,
+void GLRendererLayerTree::UpdateRootAndPartialDamagePlanes(
+    std::unique_ptr<GLRendererLayerTree> old_tree,
     const gfx::Rect& pixel_damage_rect) {
   // First update the partial damage tree.
   UpdatePartialDamagePlanes(old_tree.get(), pixel_damage_rect);
   if (old_tree) {
     if (partial_damage_planes_.empty()) {
       // If there are no partial damage planes, then we will be updating the
       // root layer. Take the CALayer from the old tree.
       root_plane_->TakeCALayerFrom(old_tree->root_plane_.get());
     } else {
       // If there is a partial damage tree, then just take the old plane
       // from the previous frame, so that there is no update to it.
       root_plane_.swap(old_tree->root_plane_);
     }
   }
 }
 
-void CALayerPartialDamageTree::UpdateCALayers(CALayer* superlayer,
-                                              float scale_factor) {
+void GLRendererLayerTree::UpdateCALayers(CALayer* superlayer,
+                                         float scale_factor) {
   if (!allow_partial_swap_) {
     DCHECK(partial_damage_planes_.empty());
     return;
   }
 
   // Allocate and update CALayers for the backbuffer and partial damage layers.
   if (!root_plane_->ca_layer) {
     DCHECK(partial_damage_planes_.empty());
     root_plane_->ca_layer.reset([[CALayer alloc] init]);
     [superlayer setSublayers:nil];
     [superlayer addSublayer:root_plane_->ca_layer];
   }
   // Excessive logging to debug white screens (crbug.com/583805).
   // TODO(ccameron): change this back to a DLOG.
   if ([root_plane_->ca_layer superlayer] != superlayer) {
-    LOG(ERROR) << "CALayerPartialDamageTree root layer not attached to tree.";
+    LOG(ERROR) << "GLRendererLayerTree root layer not attached to tree.";
   }
   for (auto& plane : partial_damage_planes_) {
     if (!plane->ca_layer) {
       DCHECK(plane == partial_damage_planes_.back());
       plane->ca_layer.reset([[CALayer alloc] init]);
     }
     if (![plane->ca_layer superlayer]) {
       DCHECK(plane == partial_damage_planes_.back());
       [superlayer addSublayer:plane->ca_layer];
     }
   }
   root_plane_->UpdateProperties(scale_factor);
   for (auto& plane : partial_damage_planes_)
     plane->UpdateProperties(scale_factor);
 }
 
-CALayerPartialDamageTree::CALayerPartialDamageTree(
+GLRendererLayerTree::GLRendererLayerTree(
     bool allow_partial_swap,
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
     const gfx::Rect& pixel_frame_rect)
     : allow_partial_swap_(allow_partial_swap) {
   root_plane_.reset(
       new OverlayPlane(io_surface, pixel_frame_rect, gfx::RectF(0, 0, 1, 1)));
 }
 
-CALayerPartialDamageTree::~CALayerPartialDamageTree() {}
+GLRendererLayerTree::~GLRendererLayerTree() {}
 
 base::ScopedCFTypeRef<IOSurfaceRef>
-CALayerPartialDamageTree::RootLayerIOSurface() {
+GLRendererLayerTree::RootLayerIOSurface() {
   return root_plane_->io_surface;
 }
 
-void CALayerPartialDamageTree::CommitCALayers(
+void GLRendererLayerTree::CommitCALayers(
     CALayer* superlayer,
-    std::unique_ptr<CALayerPartialDamageTree> old_tree,
+    std::unique_ptr<GLRendererLayerTree> old_tree,
     float scale_factor,
     const gfx::Rect& pixel_damage_rect) {
-  TRACE_EVENT0("gpu", "CALayerPartialDamageTree::CommitCALayers");
+  TRACE_EVENT0("gpu", "GLRendererLayerTree::CommitCALayers");
   UpdateRootAndPartialDamagePlanes(std::move(old_tree), pixel_damage_rect);
   UpdateCALayers(superlayer, scale_factor);
 }
 
 }  // namespace ui