cc: Replace LayerIterator with iterator that walks layer list and effect tree

cc/layers/render_surface_impl.cc

 // Copyright 2011 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 "cc/layers/render_surface_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 20 matching lines @@
 namespace cc {
 
 RenderSurfaceImpl::RenderSurfaceImpl(LayerTreeImpl* layer_tree_impl,
                                      int stable_effect_id)
     : layer_tree_impl_(layer_tree_impl),
       stable_effect_id_(stable_effect_id),
       effect_tree_index_(EffectTree::kInvalidNodeId),
       surface_property_changed_(false),
       ancestor_property_changed_(false),
       contributes_to_drawn_surface_(false),
-      nearest_occlusion_immune_ancestor_(nullptr),
-      target_render_surface_layer_index_history_(0),
-      current_layer_index_history_(0) {
+      nearest_occlusion_immune_ancestor_(nullptr) {
   damage_tracker_ = DamageTracker::Create();
 }
 
 RenderSurfaceImpl::~RenderSurfaceImpl() {}
 
 RenderSurfaceImpl* RenderSurfaceImpl::render_target() {
   EffectTree& effect_tree = layer_tree_impl_->property_trees()->effect_tree;
   EffectNode* node = effect_tree.Node(EffectTreeIndex());
   if (node->target_id != EffectTree::kRootNodeId)
     return effect_tree.GetRenderSurface(node->target_id);
@@ skipping 19 matching lines @@
 RenderSurfaceImpl::DrawProperties::~DrawProperties() {}
 
 gfx::RectF RenderSurfaceImpl::DrawableContentRect() const {
   if (content_rect().IsEmpty())
     return gfx::RectF();
 
   gfx::Rect surface_content_rect = content_rect();
   const FilterOperations& filters = Filters();
   if (!filters.IsEmpty()) {
     surface_content_rect =
-        filters.MapRect(surface_content_rect, FiltersTransform().matrix());
+        filters.MapRect(surface_content_rect, SurfaceScale().matrix());
   }
   gfx::RectF drawable_content_rect = MathUtil::MapClippedRect(
       draw_transform(), gfx::RectF(surface_content_rect));
   if (!filters.IsEmpty() && is_clipped()) {
     // Filter could move pixels around, but still need to be clipped.
     drawable_content_rect.Intersect(gfx::RectF(clip_rect()));
   }
 
   // If the rect has a NaN coordinate, we return empty rect to avoid crashes in
   // functions (for example, gfx::ToEnclosedRect) that are called on this rect.
@@ skipping 33 matching lines @@
 }
 
 const FilterOperations& RenderSurfaceImpl::Filters() const {
   return OwningEffectNode()->filters;
 }
 
 gfx::PointF RenderSurfaceImpl::FiltersOrigin() const {
   return OwningEffectNode()->filters_origin;
 }
 
-gfx::Transform RenderSurfaceImpl::FiltersTransform() const {
-  gfx::Transform filters_transform;
-  filters_transform.Scale(OwningEffectNode()->surface_contents_scale.x(),
-                          OwningEffectNode()->surface_contents_scale.y());
-  return filters_transform;
+gfx::Transform RenderSurfaceImpl::SurfaceScale() const {
+  gfx::Transform surface_scale;
+  surface_scale.Scale(OwningEffectNode()->surface_contents_scale.x(),
+                      OwningEffectNode()->surface_contents_scale.y());
+  return surface_scale;
 }
 
 const FilterOperations& RenderSurfaceImpl::BackgroundFilters() const {
   return OwningEffectNode()->background_filters;
 }
 
 bool RenderSurfaceImpl::HasCopyRequest() const {
   return OwningEffectNode()->has_copy_request;
 }
 
@@ skipping 35 matching lines @@
 }
 
 void RenderSurfaceImpl::SetContentRectForTesting(const gfx::Rect& rect) {
   SetContentRect(rect);
 }
 
 gfx::Rect RenderSurfaceImpl::CalculateExpandedClipForFilters(
     const gfx::Transform& target_to_surface) {
   gfx::Rect clip_in_surface_space =
       MathUtil::ProjectEnclosingClippedRect(target_to_surface, clip_rect());
-  gfx::Rect expanded_clip_in_surface_space = Filters().MapRectReverse(
-      clip_in_surface_space, FiltersTransform().matrix());
+  gfx::Rect expanded_clip_in_surface_space =
+      Filters().MapRectReverse(clip_in_surface_space, SurfaceScale().matrix());
   gfx::Rect expanded_clip_in_target_space = MathUtil::MapEnclosingClippedRect(
       draw_transform(), expanded_clip_in_surface_space);
   return expanded_clip_in_target_space;
 }
 
 gfx::Rect RenderSurfaceImpl::CalculateClippedAccumulatedContentRect() {
   if (HasCopyRequest() || !is_clipped())
     return accumulated_content_rect();
 
   if (accumulated_content_rect().IsEmpty())
@@ skipping 211 matching lines @@
   RenderPassDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   quad->SetNew(
       shared_quad_state, content_rect(), visible_layer_rect, GetRenderPassId(),
       mask_resource_id, gfx::ScaleRect(gfx::RectF(content_rect()),
                                        mask_uv_scale.x(), mask_uv_scale.y()),
       mask_texture_size, surface_contents_scale, FiltersOrigin(), gfx::RectF());
 }
 
 }  // namespace cc