Reset property tree indices when layer is removed from layer tree

cc/layers/layer.cc

 // Copyright 2010 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.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/location.h"
@@ skipping 236 matching lines @@
   if (parent_should_know_need_push_properties()) {
     if (parent_)
       parent_->RemoveDependentNeedsPushProperties();
     if (layer)
       layer->AddDependentNeedsPushProperties();
   }
 
   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;
 
   reset_raster_scale_to_unknown();
   if (mask_layer_.get())
     mask_layer_->reset_raster_scale_to_unknown();
   if (replica_layer_.get() && replica_layer_->mask_layer_.get())
     replica_layer_->mask_layer_->reset_raster_scale_to_unknown();
 }
@@ skipping 1244 matching lines @@
 }
 
 void Layer::DidBeginTracing() {
   // We'll be dumping layer trees as part of trace, so make sure
   // PushPropertiesTo() propagates layer debug info to the impl
   // side -- otherwise this won't happen for the the layers that
   // remain unchanged since tracing started.
   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