cc : Add LayerToPropertyTreeIndices map to PropertyTrees

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 <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 41 matching lines @@
   bool target_is_clipped;
   bool is_hidden;
   uint32_t main_thread_scrolling_reasons;
   bool scroll_tree_parent_created_by_uninheritable_criteria;
   const gfx::Transform* device_transform;
   gfx::Vector2dF scroll_snap;
   gfx::Transform compound_transform_since_render_target;
   bool axis_align_since_render_target;
   int sequence_number;
   SkColor safe_opaque_background_color;
+  std::unordered_map<int, int>* transform_node_owner_to_node_map;
+  std::unordered_map<int, int>* effect_node_owner_to_node_map;
+  std::unordered_map<int, int>* clip_node_owner_to_node_map;
+  std::unordered_map<int, int>* scroll_node_owner_to_node_map;

[ajuma, 2016/05/13 14:38:53]

DataForRecursion is starting to get pretty large. In a follow-up, how about
adding PropertyTrees* to this and then removing all the fields this gives us
from DataForRecursion?

[jaydasika, 2016/05/13 19:40:39]

Acknowledged.

 };
 
 template <typename LayerType>
 struct DataForRecursionFromChild {
   int num_copy_requests_in_subtree;
 
   DataForRecursionFromChild() : num_copy_requests_in_subtree(0) {}
 
   void Merge(const DataForRecursionFromChild& data) {
     num_copy_requests_in_subtree += data.num_copy_requests_in_subtree;
@@ skipping 274 matching lines @@
 
     node.data.applies_local_clip = layer_clips_subtree;
     node.data.resets_clip = has_unclipped_surface;
     node.data.target_is_clipped = data_for_children->target_is_clipped;
     node.data.layers_are_clipped = layers_are_clipped;
     node.data.layers_are_clipped_when_surfaces_disabled =
         layers_are_clipped_when_surfaces_disabled;
 
     data_for_children->clip_tree_parent =
         data_for_children->clip_tree->Insert(node, parent_id);
+    (*data_for_children->clip_node_owner_to_node_map)[layer->id()] = node.id;
   }
 
   layer->SetClipTreeIndex(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>
 static inline bool IsAtBoundaryOf3dRenderingContext(LayerType* layer) {
@@ skipping 134 matching lines @@
     layer->SetTransformTreeIndex(parent_index);
     if (layer->mask_layer())
       layer->mask_layer()->SetTransformTreeIndex(parent_index);
     return false;
   }
 
   data_for_children->transform_tree->Insert(TransformNode(), parent_index);
 
   TransformNode* node = data_for_children->transform_tree->back();
   layer->SetTransformTreeIndex(node->id);
+  (*data_for_children->transform_node_owner_to_node_map)[layer->id()] =
+      node->id;
   if (layer->mask_layer())
     layer->mask_layer()->SetTransformTreeIndex(node->id);
 
   node->data.scrolls = is_scrollable;
   node->data.flattens_inherited_transform = data_for_children->should_flatten;
 
   node->data.sorting_context_id = layer->sorting_context_id();
 
   if (layer == data_from_ancestor.page_scale_layer)
     data_for_children->in_subtree_of_page_scale_layer = true;
@@ skipping 334 matching lines @@
     // Root render surface acts the unbounded and untransformed to draw content
     // into. Transform node created from root layer (includes device scale
     // factor) and clip node created from root layer (include viewports) applies
     // to root render surface's content, but not root render surface itself.
     node.data.transform_id = kRootPropertyTreeNodeId;
     node.data.clip_id = kRootPropertyTreeNodeId;
   }
   data_for_children->effect_tree_parent =
       data_for_children->effect_tree->Insert(node, parent_id);
   layer->SetEffectTreeIndex(data_for_children->effect_tree_parent);
+  (*data_for_children->effect_node_owner_to_node_map)[layer->id()] = node.id;
   if (should_create_render_surface) {
     data_for_children->compound_transform_since_render_target =
         gfx::Transform();
     data_for_children->axis_align_since_render_target = true;
   }
   return should_create_render_surface;
 }
 
 template <typename LayerType>
 void AddScrollNodeIfNeeded(
@@ skipping 58 matching lines @@
     node.data.element_id = layer->element_id();
     node.data.transform_id =
         data_for_children->transform_tree_parent->transform_tree_index();
 
     data_for_children->scroll_tree_parent =
         data_for_children->scroll_tree->Insert(node, parent_id);
     data_for_children->main_thread_scrolling_reasons =
         node.data.main_thread_scrolling_reasons;
     data_for_children->scroll_tree_parent_created_by_uninheritable_criteria =
         scroll_node_uninheritable_criteria;
+    (*data_for_children->scroll_node_owner_to_node_map)[layer->id()] = node.id;
 
     if (node.data.scrollable) {
       data_for_children->scroll_tree->SetBaseScrollOffset(
           layer->id(), layer->CurrentScrollOffset());
     }
   }
 
   layer->SetScrollTreeIndex(data_for_children->scroll_tree_parent);
 }
 
@@ skipping 214 matching lines @@
   data_for_recursion.affected_by_inner_viewport_bounds_delta = false;
   data_for_recursion.affected_by_outer_viewport_bounds_delta = false;
   data_for_recursion.should_flatten = false;
   data_for_recursion.target_is_clipped = false;
   data_for_recursion.is_hidden = false;
   data_for_recursion.main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
   data_for_recursion.scroll_tree_parent_created_by_uninheritable_criteria =
       true;
   data_for_recursion.device_transform = &device_transform;
+  data_for_recursion.transform_node_owner_to_node_map =
+      &property_trees->transform_node_owner_to_node_map;
+  data_for_recursion.effect_node_owner_to_node_map =
+      &property_trees->effect_node_owner_to_node_map;
+  data_for_recursion.clip_node_owner_to_node_map =
+      &property_trees->clip_node_owner_to_node_map;
+  data_for_recursion.scroll_node_owner_to_node_map =
+      &property_trees->scroll_node_owner_to_node_map;
 
   data_for_recursion.transform_tree->clear();
   data_for_recursion.clip_tree->clear();
   data_for_recursion.effect_tree->clear();
   data_for_recursion.scroll_tree->clear();
   data_for_recursion.compound_transform_since_render_target = gfx::Transform();
   data_for_recursion.axis_align_since_render_target = true;
   data_for_recursion.sequence_number = property_trees->sequence_number;
   data_for_recursion.transform_tree->set_device_scale_factor(
       device_scale_factor);
   data_for_recursion.safe_opaque_background_color = color;
+  data_for_recursion.transform_node_owner_to_node_map->clear();
+  data_for_recursion.effect_node_owner_to_node_map->clear();
+  data_for_recursion.clip_node_owner_to_node_map->clear();
+  data_for_recursion.scroll_node_owner_to_node_map->clear();
 
   ClipNode root_clip;
   root_clip.data.resets_clip = true;
   root_clip.data.applies_local_clip = true;
   root_clip.data.clip = gfx::RectF(viewport);
   root_clip.data.transform_id = kRootPropertyTreeNodeId;
   data_for_recursion.clip_tree_parent =
       data_for_recursion.clip_tree->Insert(root_clip, kRootPropertyTreeNodeId);
 
   DataForRecursionFromChild<LayerType> data_from_child;
@@ skipping 76 matching lines @@
   if (SkColorGetA(color) != 255)
     color = SkColorSetA(color, 255);
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees, color);
 }
 
 }  // namespace cc