Reset property tree indices when layer is removed from layer tree

cc/layers/layer.cc

Index: cc/layers/layer.cc
diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index 44679fcff16ab06fab76b2e17acdf7459885d89a..78c8591841a5f26301907ca5aefad47e765c557e 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -254,8 +254,14 @@ void Layer::SetParent(Layer* layer) {
   parent_ = layer;
   SetLayerTreeHost(parent_ ? parent_->layer_tree_host() : nullptr);
 
+  if (!layer)
+    InvalidatePropertyTreeIndices();

[ajuma, 2015/05/20 13:54:03]

I'm a bit worried about the perf impact of this. Is the idea that we expect the
tree to be shallow, so O(height of the tree) isn't too much work? (This will
also make tree destruction O(n^2) in the worst case, since we disconnect layers
from their parents starting with the root's children and then proceeding
downwards, but maybe that's not too serious since it only happens once in the
life of the tree.)

An alternative would be to store a property tree version number, and then we'd
have a quick way of checking if our tree indices are stale.

WDYT?

+
   if (!layer_tree_host_)
     return;
+
+  layer_tree_host_->property_trees()->needs_rebuild = true;
+
   const LayerTreeSettings& settings = layer_tree_host_->settings();
   if (!settings.layer_transforms_should_scale_layer_contents)
     return;
@@ -1520,4 +1526,15 @@ void Layer::DidBeginTracing() {
   SetNeedsPushProperties();
 }
 
+void Layer::InvalidatePropertyTreeIndices() {
+  transform_tree_index_ = -1;
+  clip_tree_index_ = -1;
+  opacity_tree_index_ = -1;
+
+  for (size_t i = 0; i < children().size(); ++i) {
+    Layer* child_layer = child_at(i);
+    child_layer->InvalidatePropertyTreeIndices();
+  }
+}
+
 }  // namespace cc