Reset property tree indices when layer is removed from layer tree

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 <map>
 #include <set>
 
 #include "cc/base/math_util.h"
@@ skipping 20 matching lines @@
   int clip_tree_parent;
   int opacity_tree_parent;
   const LayerType* page_scale_layer;
   float page_scale_factor;
   float device_scale_factor;
   bool in_subtree_of_page_scale_application_layer;
   bool should_flatten;
   bool ancestor_clips_subtree;
   const gfx::Transform* device_transform;
   gfx::Vector2dF scroll_compensation_adjustment;
+  int sequence_number;
 };
 
 template <typename LayerType>
 static LayerType* GetTransformParent(const DataForRecursion<LayerType>& data,
                                      LayerType* layer) {
   return layer->position_constraint().is_fixed_position()
              ? data.transform_fixed_parent
              : data.transform_tree_parent;
 }
 
@@ skipping 90 matching lines @@
         gfx::PointF() + layer->offset_to_transform_parent(), layer->bounds());
     node.data.transform_id = transform_parent->transform_tree_index();
     node.data.target_id =
         data_for_children->render_target->transform_tree_index();
     node.owner_id = layer->id();
 
     data_for_children->clip_tree_parent =
         data_for_children->clip_tree->Insert(node, parent_id);
   }
 
-  layer->set_clip_tree_index(
+  layer->SetClipTreeIndex(
       has_unclipped_surface ? 0 : data_for_children->clip_tree_parent);
 
   // TODO(awoloszyn): Right now when we hit a node with a replica, we reset the
   // clip for all children since we may need to draw. We need to figure out a
   // better way, since we will need both the clipped and unclipped versions.
 }
 
 template <typename LayerType>
 bool AddTransformNodeIfNeeded(
     const DataForRecursion<LayerType>& data_from_ancestor,
@@ skipping 64 matching lines @@
     if (source_index != parent_index) {
       gfx::Transform to_parent;
       data_from_ancestor.transform_tree->ComputeTransform(
           source_index, parent_index, &to_parent);
       source_to_parent = to_parent.To2dTranslation();
     }
     layer->set_offset_to_transform_parent(source_offset + source_to_parent +
                                           local_offset);
     layer->set_should_flatten_transform_from_property_tree(
         data_from_ancestor.should_flatten);
-    layer->set_transform_tree_index(parent_index);
+    layer->SetTransformTreeIndex(parent_index);
     return false;
   }
 
   data_for_children->transform_tree->Insert(TransformNode(), parent_index);
 
   TransformNode* node = data_for_children->transform_tree->back();
-  layer->set_transform_tree_index(node->id);
+  layer->SetTransformTreeIndex(node->id);
 
   node->data.scrolls = is_scrollable;
   node->data.flattens_inherited_transform = data_for_children->should_flatten;
 
   // Surfaces inherently flatten transforms.
   data_for_children->should_flatten =
       layer->should_flatten_transform() || has_surface;
   node->data.target_id =
       data_from_ancestor.render_target->transform_tree_index();
   node->data.content_target_id =
@@ skipping 65 matching lines @@
     LayerType* layer,
     DataForRecursion<LayerType>* data_for_children) {
   const bool is_root = !layer->parent();
   const bool has_transparency = layer->opacity() != 1.f;
   const bool has_animated_opacity = IsAnimatingOpacity(layer);
   bool requires_node = is_root || has_transparency || has_animated_opacity;
 
   int parent_id = data_from_ancestor.opacity_tree_parent;
 
   if (!requires_node) {
-    layer->set_opacity_tree_index(parent_id);
+    layer->SetOpacityTreeIndex(parent_id);
     data_for_children->opacity_tree_parent = parent_id;
     return;
   }
 
   OpacityNode node;
   node.owner_id = layer->id();
   node.data = layer->opacity();
   data_for_children->opacity_tree_parent =
       data_for_children->opacity_tree->Insert(node, parent_id);
-  layer->set_opacity_tree_index(data_for_children->opacity_tree_parent);
+  layer->SetOpacityTreeIndex(data_for_children->opacity_tree_parent);
 }
 
 template <typename LayerType>
 void BuildPropertyTreesInternal(
     LayerType* layer,
     const DataForRecursion<LayerType>& data_from_parent) {
+  layer->set_property_tree_sequence_number(data_from_parent.sequence_number);
   DataForRecursion<LayerType> data_for_children(data_from_parent);
   if (layer->render_surface())
     data_for_children.render_target = layer;
 
   bool created_transform_node =
       AddTransformNodeIfNeeded(data_from_parent, layer, &data_for_children);
   AddClipNodeIfNeeded(data_from_parent, layer, created_transform_node,
                       &data_for_children);
 
   if (data_from_parent.opacity_tree)
@@ skipping 20 matching lines @@
 }  // namespace
 
 template <typename LayerType>
 void BuildPropertyTreesTopLevelInternal(LayerType* root_layer,
                                         const LayerType* page_scale_layer,
                                         float page_scale_factor,
                                         float device_scale_factor,
                                         const gfx::Rect& viewport,
                                         const gfx::Transform& device_transform,
                                         PropertyTrees* property_trees) {
+  property_trees->sequence_number++;
+
   DataForRecursion<LayerType> data_for_recursion;
   data_for_recursion.transform_tree = &property_trees->transform_tree;
   data_for_recursion.clip_tree = &property_trees->clip_tree;
   data_for_recursion.opacity_tree = &property_trees->opacity_tree;
   data_for_recursion.transform_tree_parent = nullptr;
   data_for_recursion.transform_fixed_parent = nullptr;
   data_for_recursion.render_target = root_layer;
   data_for_recursion.clip_tree_parent = 0;
   data_for_recursion.opacity_tree_parent = -1;
   data_for_recursion.page_scale_layer = page_scale_layer;
   data_for_recursion.page_scale_factor = page_scale_factor;
   data_for_recursion.device_scale_factor = device_scale_factor;
   data_for_recursion.in_subtree_of_page_scale_application_layer = false;
   data_for_recursion.should_flatten = false;
   data_for_recursion.ancestor_clips_subtree = true;
   data_for_recursion.device_transform = &device_transform;
 
   data_for_recursion.transform_tree->clear();
   data_for_recursion.clip_tree->clear();
   data_for_recursion.opacity_tree->clear();
+  data_for_recursion.sequence_number = property_trees->sequence_number;
 
   ClipNode root_clip;
   root_clip.data.clip = viewport;
   root_clip.data.transform_id = 0;
   data_for_recursion.clip_tree_parent =
       data_for_recursion.clip_tree->Insert(root_clip, 0);
   BuildPropertyTreesInternal(root_layer, data_for_recursion);
   property_trees->needs_rebuild = false;
 
   // The transform tree is kept up-to-date as it is built, but the
@@ skipping 27 matching lines @@
     float device_scale_factor,
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
     PropertyTrees* property_trees) {
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, page_scale_factor, device_scale_factor,
       viewport, device_transform, property_trees);
 }
 
 }  // namespace cc