cc: Move main thread hierarchy dependencies into PropertyTreeBuilder

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 53 matching lines @@
   DCHECK(layer->background_filters().IsEmpty()) << "layer: " << layer->id();
   DCHECK(!IsRootLayer(layer)) << "layer: " << layer->id();
   if (EffectNodeOwner(layer)->replica_layer() == layer)
     return;
   DCHECK(!layer->mask_layer()) << "layer: " << layer->id();
   DCHECK(!layer->replica_layer()) << "layer: " << layer->id();
   DCHECK(!layer->HasCopyRequest()) << "layer: " << layer->id();
   ValidateIsNotRootForIsolatedGroup(layer);
 }
 
-static void ValidateRenderSurfacesRecursive(Layer* layer) {
-  ValidateRenderSurfaceForLayer(layer);
-  for (size_t i = 0; i < layer->children().size(); ++i)
-    ValidateRenderSurfacesRecursive(layer->child_at(i));
-}
 #endif
 
 template <typename LayerType>
 void CalculateVisibleRects(
     const typename LayerType::LayerListType& visible_layer_list,
     const ClipTree& clip_tree,
     const TransformTree& transform_tree,
     bool non_root_surfaces_enabled) {
   for (auto& layer : visible_layer_list) {
     gfx::Size layer_bounds = layer->bounds();
@@ skipping 277 matching lines @@
   }
 
   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) {
-    UpdateRenderSurfacesForLayersRecursive(effect_tree, layer->child_at(i));
-  }
-}
-
 }  // namespace
 
 template <typename LayerType>
 static inline bool LayerShouldBeSkippedInternal(
     LayerType* layer,
     bool layer_is_drawn,
     const TransformTree& transform_tree,
     const EffectTree& effect_tree) {
   const TransformNode* transform_node =
       transform_tree.Node(layer->transform_tree_index());
@@ skipping 256 matching lines @@
 
   FindLayersThatNeedUpdates(
       root_layer->layer_tree_impl(), property_trees->transform_tree,
       property_trees->effect_tree, update_layer_list, visible_layer_list);
   CalculateVisibleRects<LayerImpl>(
       *visible_layer_list, property_trees->clip_tree,
       property_trees->transform_tree, can_render_to_separate_surface);
 }
 
 void UpdateRenderSurfaces(Layer* root_layer, PropertyTrees* property_trees) {
-  UpdateRenderSurfacesForLayersRecursive(&property_trees->effect_tree,
-                                         root_layer);
+  for (auto* layer : *root_layer->layer_tree_host()) {
+    UpdateRenderSurfaceForLayer(&property_trees->effect_tree, true, layer);
 #if DCHECK_IS_ON()
-  ValidateRenderSurfacesRecursive(root_layer);
+    ValidateRenderSurfaceForLayer(layer);
 #endif
+  }
 }
 
 void UpdatePropertyTrees(PropertyTrees* property_trees,
                          bool can_render_to_separate_surface) {
   if (property_trees->non_root_surfaces_enabled !=
       can_render_to_separate_surface) {
     property_trees->non_root_surfaces_enabled = can_render_to_separate_surface;
     property_trees->transform_tree.set_needs_update(true);
   }
   if (property_trees->transform_tree.needs_update())
@@ skipping 450 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