Rebuild PropertyTrees When Layer Attach to New LayerTreeHost

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 114 matching lines @@
   }
 }
 
 void Layer::SetLayerTreeHost(LayerTreeHost* host) {
   if (layer_tree_host_ == host)
     return;
 
   if (layer_tree_host_)
     layer_tree_host_->property_trees()->needs_rebuild = true;
 
+  if (host)
+    host->property_trees()->needs_rebuild = true;
+
+  InvalidatePropertyTreesIndices();

[Ian Vollick, 2015/06/09 00:18:51]

Is there a chance that we're detaching/attaching a subtree rather than a single
layer?

If we'll never have a tiny subtree, then please DCHECK that there can be no
children.

If we could have a subtree, then you're looking at a walk over that subtree to
set all the indices to -1 which would be unfortunate -- the sequence numbers
were added so we could avoid that very thing
(https://code.google.com/p/chromium/codesearch#chromium/src/cc/layers/layer.cc...).
It seems like setting needs_rebuild = true implies that all the indices are
dirty. Perhaps PropertyTrees should stop being a dumb struct and define a
SetNeedsRebuild fn that sets the needs rebuild bit as well as bumping the
sequence number?

+
   layer_tree_host_ = host;
 
   // When changing hosts, the layer needs to commit its properties to the impl
   // side for the new host.
   SetNeedsPushProperties();
 
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SetLayerTreeHost(host);
 
   if (mask_layer_.get())
@@ skipping 901 matching lines @@
 
 int Layer::opacity_tree_index() const {
   if (!layer_tree_host_ ||
       layer_tree_host_->property_trees()->sequence_number !=
           property_tree_sequence_number_) {
     return -1;
   }
   return opacity_tree_index_;
 }
 
+void Layer::InvalidatePropertyTreesIndices() {
+  int invalid_property_tree_index = -1;
+  SetTransformTreeIndex(invalid_property_tree_index);
+  SetClipTreeIndex(invalid_property_tree_index);
+  SetOpacityTreeIndex(invalid_property_tree_index);
+}
+
 void Layer::SetShouldFlattenTransform(bool should_flatten) {
   DCHECK(IsPropertyChangeAllowed());
   if (should_flatten_transform_ == should_flatten)
     return;
   should_flatten_transform_ = should_flatten;
   SetNeedsCommit();
 }
 
 void Layer::SetIsDrawable(bool is_drawable) {
   DCHECK(IsPropertyChangeAllowed());
@@ skipping 581 matching lines @@
           ? layer_tree_host()->meta_information_sequence_number()
           : 0;
 }
 
 bool Layer::sorted_for_recursion() {
   return sorted_for_recursion_tracker_ ==
          layer_tree_host()->meta_information_sequence_number();
 }
 
 }  // namespace cc