cc : Update render surfaces using LayerListIterator instead of treewalk

cc/trees/draw_property_utils.cc

 // 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 "cc/trees/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 435 matching lines @@
       update_layer_list->push_back(mask_layer);
   }
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     FindLayersThatNeedUpdates(layer->child_at(i), transform_tree, effect_tree,
                               update_layer_list, visible_layer_list);
   }
 }
 
 template <typename LayerType>
-void UpdateRenderSurfacesWithEffectTreeInternal(EffectTree* effect_tree,
-                                                LayerType* layer) {
+void UpdateRenderSurfaceForLayer(EffectTree* effect_tree,
+                                 bool non_root_surfaces_enabled,
+                                 LayerType* layer) {
+  if (!non_root_surfaces_enabled) {
+    layer->SetHasRenderSurface(!layer->parent());
+    return;
+  }
   EffectNode* node = effect_tree->Node(layer->effect_tree_index());
 
   if (node->owner_id == layer->id() && node->data.has_render_surface)
     layer->SetHasRenderSurface(true);
   else
     layer->SetHasRenderSurface(false);
+}
+
+void UpdateRenderSurfacesForLayersRecursive(EffectTree* effect_tree,
+                                            Layer* layer) {
+  UpdateRenderSurfaceForLayer(effect_tree, true, layer);
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
-    UpdateRenderSurfacesWithEffectTreeInternal<LayerType>(effect_tree,
-                                                          layer->child_at(i));
+    UpdateRenderSurfacesForLayersRecursive(effect_tree, layer->child_at(i));
   }
 }
 
-void UpdateRenderSurfacesWithEffectTree(EffectTree* effect_tree, Layer* layer) {
-  UpdateRenderSurfacesWithEffectTreeInternal<Layer>(effect_tree, layer);
-}
-
-void UpdateRenderSurfacesNonRootSurfacesDisabled(LayerImpl* layer) {
-  // Only root layer has render surface, all other layers don't.
-  layer->SetHasRenderSurface(!layer->parent());
-
-  for (size_t i = 0; i < layer->children().size(); ++i)
-    UpdateRenderSurfacesNonRootSurfacesDisabled(layer->child_at(i));
-}
-
-void UpdateRenderSurfacesWithEffectTree(EffectTree* effect_tree,
-                                        bool non_root_surfaces_enabled,
-                                        LayerImpl* layer) {
-  if (!non_root_surfaces_enabled)
-    UpdateRenderSurfacesNonRootSurfacesDisabled(layer);
-  else
-    UpdateRenderSurfacesWithEffectTreeInternal<LayerImpl>(effect_tree, layer);
-}
-
 }  // namespace
 
 static void ResetIfHasNanCoordinate(gfx::RectF* rect) {
   if (std::isnan(rect->x()) || std::isnan(rect->y()) ||
       std::isnan(rect->right()) || std::isnan(rect->bottom()))
     *rect = gfx::RectF();
 }
 
 void ComputeClips(ClipTree* clip_tree,
                   const TransformTree& transform_tree,
@@ skipping 188 matching lines @@
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
     bool can_render_to_separate_surface,
     PropertyTrees* property_trees,
     LayerList* update_layer_list) {
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees);
-  UpdateRenderSurfacesWithEffectTree(&property_trees->effect_tree, root_layer);
+  UpdateRenderSurfacesForLayersRecursive(&property_trees->effect_tree,
+                                         root_layer);
   ValidateRenderSurfaces(root_layer);
   ComputeVisibleRects(root_layer, property_trees,
                       can_render_to_separate_surface, update_layer_list);
 }
 
 void BuildPropertyTreesAndComputeVisibleRects(
     LayerImpl* root_layer,
     const LayerImpl* page_scale_layer,
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
@@ skipping 22 matching lines @@
   std::vector<Layer*> visible_layer_list;
   ComputeVisibleRectsInternal(root_layer, property_trees,
                               can_render_to_separate_surface, update_layer_list,
                               &visible_layer_list);
 }
 
 void ComputeVisibleRects(LayerImpl* root_layer,
                          PropertyTrees* property_trees,
                          bool can_render_to_separate_surface,
                          LayerImplList* visible_layer_list) {
-  UpdateRenderSurfacesWithEffectTree(
-      &property_trees->effect_tree, can_render_to_separate_surface, root_layer);
+  for (auto* layer : *root_layer->layer_tree_impl())
+    UpdateRenderSurfaceForLayer(&property_trees->effect_tree,
+                                can_render_to_separate_surface, layer);
   if (can_render_to_separate_surface)
     ValidateRenderSurfaces(root_layer);
   LayerImplList update_layer_list;
   ComputeVisibleRectsInternal(root_layer, property_trees,
                               can_render_to_separate_surface,
                               &update_layer_list, visible_layer_list);
 }
 
 template <typename LayerType>
 static gfx::Transform DrawTransformInternal(const LayerType* layer,
@@ skipping 375 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc