cc : Move LayerImpl::children to test properties

cc/layers/layer_impl.cc

 // Copyright 2012 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/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 91 matching lines @@
   layer_tree_impl_->RemoveFromElementMap(this);
 
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerImpl", this);
 
   // The mask and replica layers should have been removed already.
   if (mask_layer_)
     DCHECK(!layer_tree_impl_->RemoveLayer(mask_layer_id_));
   if (replica_layer_)
     DCHECK(!layer_tree_impl_->RemoveLayer(replica_layer_id_));
-  children_.clear();
 }
 
 void LayerImpl::AddChild(std::unique_ptr<LayerImpl> child) {
   child->SetParent(this);
   DCHECK_EQ(layer_tree_impl(), child->layer_tree_impl());
-  children_.push_back(child.get());
+  test_properties()->children.push_back(child.get());
   layer_tree_impl_->AddLayer(std::move(child));
 }

[ajuma, 2016/06/09 23:39:47]

AddChild and RemoveChild should also (eventually) move to
LayerImplTestProperties.

[jaydasika, 2016/06/10 02:13:39]

Acknowledged.

 
 std::unique_ptr<LayerImpl> LayerImpl::RemoveChildForTesting(LayerImpl* child) {
-  auto it = std::find(children_.begin(), children_.end(), child);
-  if (it != children_.end())
-    children_.erase(it);
+  auto it = std::find(test_properties()->children.begin(),
+                      test_properties()->children.end(), child);
+  if (it != test_properties()->children.end())
+    test_properties()->children.erase(it);
   layer_tree_impl()->property_trees()->RemoveIdFromIdToIndexMaps(child->id());
   return layer_tree_impl_->RemoveLayer(child->id());
 }
 
 void LayerImpl::SetParent(LayerImpl* parent) {
   parent_ = parent;
 }
 
 void LayerImpl::ClearLinksToOtherLayers() {
-  children_.clear();
   mask_layer_ = nullptr;
   replica_layer_ = nullptr;
 }
 
 void LayerImpl::SetHasWillChangeTransformHint(bool has_will_change) {
   if (has_will_change_transform_hint_ == has_will_change)
     return;
   has_will_change_transform_hint_ = has_will_change;
   SetNeedsPushProperties();
 }
@@ skipping 280 matching lines @@
 
 gfx::Vector2dF LayerImpl::FixedContainerSizeDelta() const {
   LayerImpl* scroll_clip_layer =
       layer_tree_impl()->LayerById(scroll_clip_layer_id_);
   if (!scroll_clip_layer)
     return gfx::Vector2dF();
 
   return scroll_clip_layer->bounds_delta();
 }
 
-std::unique_ptr<base::DictionaryValue> LayerImpl::LayerTreeAsJson() const {
+std::unique_ptr<base::DictionaryValue> LayerImpl::LayerTreeAsJson() {
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
   result->SetInteger("LayerId", id());
   result->SetString("LayerType", LayerTypeAsString());
 
   base::ListValue* list = new base::ListValue;
   list->AppendInteger(bounds().width());
   list->AppendInteger(bounds().height());
   result->Set("Bounds", list);
 
   list = new base::ListValue;
@@ skipping 16 matching lines @@
 
   if (scrollable())
     result->SetBoolean("Scrollable", true);
 
   if (!touch_event_handler_region_.IsEmpty()) {
     std::unique_ptr<base::Value> region = touch_event_handler_region_.AsValue();
     result->Set("TouchRegion", region.release());
   }
 
   list = new base::ListValue;
-  for (size_t i = 0; i < children_.size(); ++i)
-    list->Append(children_[i]->LayerTreeAsJson());
+  for (size_t i = 0; i < test_properties()->children.size(); ++i)
+    list->Append(test_properties()->children[i]->LayerTreeAsJson());
   result->Set("Children", list);
 
   return result;
 }
 
 bool LayerImpl::LayerPropertyChanged() const {
   if (layer_property_changed_ ||
       (layer_tree_impl()->property_trees() &&
        layer_tree_impl()->property_trees()->full_tree_damaged))
     return true;
@@ skipping 872 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       ScreenSpaceTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc