cc : Move LayerImpl::children to test properties

cc/trees/property_tree_builder.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/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 122 matching lines @@
   if (IsRootLayer(layer))
     layer->layer_tree_host()->SetNeedsMetaInfoRecomputation(false);
 }
 
 static void PreCalculateMetaInformationInternalForTesting(
     LayerImpl* layer,
     PreCalculateMetaInformationRecursiveData* recursive_data) {
   if (layer->test_properties()->clip_parent)
     recursive_data->num_unclipped_descendants++;
 
-  for (size_t i = 0; i < layer->children().size(); ++i) {
-    LayerImpl* child_layer = layer->child_at(i);
+  for (size_t i = 0; i < layer->test_properties()->children.size(); ++i) {
+    LayerImpl* child_layer = layer->test_properties()->children[i];
 
     PreCalculateMetaInformationRecursiveData data_for_child;
     PreCalculateMetaInformationInternalForTesting(child_layer, &data_for_child);
     recursive_data->Merge(data_for_child);
   }
 
   if (layer->test_properties()->clip_children) {
     size_t num_clip_children = layer->test_properties()->clip_children->size();
     DCHECK_GE(recursive_data->num_unclipped_descendants, num_clip_children);
     recursive_data->num_unclipped_descendants -= num_clip_children;
   }
 
   layer->test_properties()->num_unclipped_descendants =
       recursive_data->num_unclipped_descendants;
   // TODO(enne): this should be synced from the main thread, so is only
   // for tests constructing layers on the compositor thread.
   layer->test_properties()->num_descendants_that_draw_content =
       recursive_data->num_descendants_that_draw_content;
 
   if (layer->DrawsContent())
     recursive_data->num_descendants_that_draw_content++;
 }
 
+static LayerImplList& Children(LayerImpl* layer) {
+  return layer->test_properties()->children;
+}
+
+static const LayerList& Children(Layer* layer) {
+  return layer->children();
+}
+
+static LayerImpl* ChildAt(LayerImpl* layer, int index) {
+  return layer->test_properties()->children[index];
+}
+
+static Layer* ChildAt(Layer* layer, int index) {
+  return layer->child_at(index);
+}
+
 static Layer* ScrollParent(Layer* layer) {
   return layer->scroll_parent();
 }
 
 static LayerImpl* ScrollParent(LayerImpl* layer) {
   return layer->test_properties()->scroll_parent;
 }
 
 static std::set<Layer*>* ScrollChildren(Layer* layer) {
   return layer->scroll_children();
@@ skipping 893 matching lines @@
   bool created_transform_node = AddTransformNodeIfNeeded(
       data_from_parent, layer, created_render_surface, &data_for_children);
   AddClipNodeIfNeeded(data_from_parent, layer, created_render_surface,
                       created_transform_node, &data_for_children);
 
   AddScrollNodeIfNeeded(data_from_parent, layer, &data_for_children);
 
   SetBackfaceVisibilityTransform(layer, created_transform_node);
   SetSafeOpaqueBackgroundColor(data_from_parent, layer, &data_for_children);
 
-  for (size_t i = 0; i < layer->children().size(); ++i) {
-    SetLayerPropertyChangedForChild(layer, layer->child_at(i));
-    if (!ScrollParent(layer->child_at(i))) {
+  for (size_t i = 0; i < Children(layer).size(); ++i) {
+    LayerType* current_child = ChildAt(layer, i);
+    SetLayerPropertyChangedForChild(layer, current_child);
+    if (!ScrollParent(current_child)) {
       DataForRecursionFromChild<LayerType> data_from_child;
-      BuildPropertyTreesInternal(layer->child_at(i), data_for_children,
+      BuildPropertyTreesInternal(current_child, data_for_children,
                                  &data_from_child);
       data_to_parent->Merge(data_from_child);
     } else {
       // The child should be included in its scroll parent's list of scroll
       // children.
-      DCHECK(ScrollChildren(ScrollParent(layer->child_at(i)))
-                 ->count(layer->child_at(i)));
+      DCHECK(ScrollChildren(ScrollParent(current_child))->count(current_child));
     }
   }
 
   if (ScrollChildren(layer)) {
     for (LayerType* scroll_child : *ScrollChildren(layer)) {
       DCHECK_EQ(ScrollParent(scroll_child), layer);
       DataForRecursionFromChild<LayerType> data_from_child;
       DCHECK(scroll_child->parent());
       data_for_children.effect_tree_parent =
           scroll_child->parent()->effect_tree_index();
@@ skipping 223 matching lines @@
   if (SkColorGetA(color) != 255)
     color = SkColorSetA(color, 255);
   BuildPropertyTreesTopLevelInternal(
       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, color);
 }
 
 }  // namespace cc