cc : Add LayerToPropertyTreeIndices map to PropertyTrees

cc/trees/property_tree.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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 99 matching lines @@
 
 template <typename T>
 void PropertyTree<T>::ToProtobuf(proto::PropertyTree* proto) const {
   DCHECK_EQ(0, proto->nodes_size());
   for (const auto& node : nodes_)
     node.ToProtobuf(proto->add_nodes());
   proto->set_needs_update(needs_update_);
 }
 
 template <typename T>
-void PropertyTree<T>::FromProtobuf(const proto::PropertyTree& proto) {
+void PropertyTree<T>::FromProtobuf(
+    const proto::PropertyTree& proto,
+    std::unordered_map<int, int>* node_id_to_index_map) {
   // Verify that the property tree is empty.
   DCHECK_EQ(static_cast<int>(nodes_.size()), 1);
   DCHECK_EQ(back()->id, 0);
   DCHECK_EQ(back()->parent_id, -1);
 
   // Add the first node.
   DCHECK_GT(proto.nodes_size(), 0);
   nodes_.back().FromProtobuf(proto.nodes(0));
 
+  DCHECK(!node_id_to_index_map || (*node_id_to_index_map).empty());
   for (int i = 1; i < proto.nodes_size(); ++i) {
     nodes_.push_back(T());
     nodes_.back().FromProtobuf(proto.nodes(i));
+    (*node_id_to_index_map)[nodes_.back().owner_id] = nodes_.back().id;
   }
 
   needs_update_ = proto.needs_update();
 }
 
 template <typename T>
 void PropertyTree<T>::AsValueInto(base::trace_event::TracedValue* value) const {
   value->BeginArray("nodes");
   for (const auto& node : nodes_) {
     value->BeginDictionary();
@@ skipping 1131 matching lines @@
   data->set_device_scale_factor(device_scale_factor_);
   data->set_device_transform_scale_factor(device_transform_scale_factor_);
 
   for (auto i : nodes_affected_by_inner_viewport_bounds_delta_)
     data->add_nodes_affected_by_inner_viewport_bounds_delta(i);
 
   for (auto i : nodes_affected_by_outer_viewport_bounds_delta_)
     data->add_nodes_affected_by_outer_viewport_bounds_delta(i);
 }
 
-void TransformTree::FromProtobuf(const proto::PropertyTree& proto) {
+void TransformTree::FromProtobuf(
+    const proto::PropertyTree& proto,
+    std::unordered_map<int, int>* node_id_to_index_map) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Transform);
 
-  PropertyTree::FromProtobuf(proto);
+  PropertyTree::FromProtobuf(proto, node_id_to_index_map);
   const proto::TransformTreeData& data = proto.transform_tree_data();
 
   source_to_parent_updates_allowed_ = data.source_to_parent_updates_allowed();
   page_scale_factor_ = data.page_scale_factor();
   device_scale_factor_ = data.device_scale_factor();
   device_transform_scale_factor_ = data.device_transform_scale_factor();
 
   DCHECK(nodes_affected_by_inner_viewport_bounds_delta_.empty());
   for (int i = 0; i < data.nodes_affected_by_inner_viewport_bounds_delta_size();
        ++i) {
@@ skipping 153 matching lines @@
   return PropertyTree::operator==(other);
 }
 
 void ClipTree::ToProtobuf(proto::PropertyTree* proto) const {
   DCHECK(!proto->has_property_type());
   proto->set_property_type(proto::PropertyTree::Clip);
 
   PropertyTree::ToProtobuf(proto);
 }
 
-void ClipTree::FromProtobuf(const proto::PropertyTree& proto) {
+void ClipTree::FromProtobuf(
+    const proto::PropertyTree& proto,
+    std::unordered_map<int, int>* node_id_to_index_map) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Clip);
 
-  PropertyTree::FromProtobuf(proto);
+  PropertyTree::FromProtobuf(proto, node_id_to_index_map);
 }
 
 bool EffectTree::operator==(const EffectTree& other) const {
   return PropertyTree::operator==(other);
 }
 
 void EffectTree::ToProtobuf(proto::PropertyTree* proto) const {
   DCHECK(!proto->has_property_type());
   proto->set_property_type(proto::PropertyTree::Effect);
 
   PropertyTree::ToProtobuf(proto);
 }
 
-void EffectTree::FromProtobuf(const proto::PropertyTree& proto) {
+void EffectTree::FromProtobuf(
+    const proto::PropertyTree& proto,
+    std::unordered_map<int, int>* node_id_to_index_map) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Effect);
 
-  PropertyTree::FromProtobuf(proto);
+  PropertyTree::FromProtobuf(proto, node_id_to_index_map);
 }
 
 ScrollTree::ScrollTree()
     : currently_scrolling_node_id_(-1),
       layer_id_to_scroll_offset_map_(ScrollTree::ScrollOffsetMap()) {}
 
 ScrollTree::ScrollTree(const ScrollTree& other) = default;
 
 ScrollTree::~ScrollTree() {}
 
@@ skipping 44 matching lines @@
   for (auto i : layer_id_to_scroll_offset_map_) {
     data->add_layer_id_to_scroll_offset_map();
     proto::ScrollOffsetMapEntry* entry =
         data->mutable_layer_id_to_scroll_offset_map(
             data->layer_id_to_scroll_offset_map_size() - 1);
     entry->set_layer_id(i.first);
     SyncedScrollOffsetToProto(*i.second.get(), entry->mutable_scroll_offset());
   }
 }
 
-void ScrollTree::FromProtobuf(const proto::PropertyTree& proto) {
+void ScrollTree::FromProtobuf(
+    const proto::PropertyTree& proto,
+    std::unordered_map<int, int>* node_id_to_index_map) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Scroll);
 
-  PropertyTree::FromProtobuf(proto);
+  PropertyTree::FromProtobuf(proto, node_id_to_index_map);
   const proto::ScrollTreeData& data = proto.scroll_tree_data();
 
   currently_scrolling_node_id_ = data.currently_scrolling_node_id();
 
   // TODO(khushalsagar): This should probably be removed if the copy constructor
   // for ScrollTree copies the |layer_id_to_scroll_offset_map_| as well.
   layer_id_to_scroll_offset_map_.clear();
   for (int i = 0; i < data.layer_id_to_scroll_offset_map_size(); ++i) {
     const proto::ScrollOffsetMapEntry entry =
         data.layer_id_to_scroll_offset_map(i);
@@ skipping 339 matching lines @@
 }
 
 PropertyTrees::PropertyTrees(const PropertyTrees& other) = default;
 
 PropertyTrees::~PropertyTrees() {}
 
 bool PropertyTrees::operator==(const PropertyTrees& other) const {
   return transform_tree == other.transform_tree &&
          effect_tree == other.effect_tree && clip_tree == other.clip_tree &&
          scroll_tree == other.scroll_tree &&
+         transform_id_to_index_map == other.transform_id_to_index_map &&
+         effect_id_to_index_map == other.effect_id_to_index_map &&
+         clip_id_to_index_map == other.clip_id_to_index_map &&
+         scroll_id_to_index_map == other.scroll_id_to_index_map &&
          needs_rebuild == other.needs_rebuild && changed == other.changed &&
          full_tree_damaged == other.full_tree_damaged &&
          is_main_thread == other.is_main_thread &&
          is_active == other.is_active &&
          non_root_surfaces_enabled == other.non_root_surfaces_enabled &&
          sequence_number == other.sequence_number;
 }
 
 PropertyTrees& PropertyTrees::operator=(const PropertyTrees& from) {
   transform_tree = from.transform_tree;
   effect_tree = from.effect_tree;
   clip_tree = from.clip_tree;
   scroll_tree = from.scroll_tree;
+  transform_id_to_index_map = from.transform_id_to_index_map;
+  effect_id_to_index_map = from.effect_id_to_index_map;
+  clip_id_to_index_map = from.clip_id_to_index_map;
+  scroll_id_to_index_map = from.scroll_id_to_index_map;
   needs_rebuild = from.needs_rebuild;
   changed = from.changed;
   full_tree_damaged = from.full_tree_damaged;
   non_root_surfaces_enabled = from.non_root_surfaces_enabled;
   sequence_number = from.sequence_number;
   is_main_thread = from.is_main_thread;
   is_active = from.is_active;
   inner_viewport_container_bounds_delta_ =
       from.inner_viewport_container_bounds_delta();
   outer_viewport_container_bounds_delta_ =
@@ skipping 21 matching lines @@
   proto->set_is_main_thread(is_main_thread);
   proto->set_is_active(is_active);
 
   // TODO(khushalsagar): Consider using the sequence number to decide if
   // property trees need to be serialized again for a commit. See crbug/555370.
   proto->set_sequence_number(sequence_number);
 }
 
 // static
 void PropertyTrees::FromProtobuf(const proto::PropertyTrees& proto) {
-  transform_tree.FromProtobuf(proto.transform_tree());
-  effect_tree.FromProtobuf(proto.effect_tree());
-  clip_tree.FromProtobuf(proto.clip_tree());
-  scroll_tree.FromProtobuf(proto.scroll_tree());
+  transform_tree.FromProtobuf(proto.transform_tree(),
+                              &transform_id_to_index_map);
+  effect_tree.FromProtobuf(proto.effect_tree(), &effect_id_to_index_map);
+  clip_tree.FromProtobuf(proto.clip_tree(), &clip_id_to_index_map);
+  scroll_tree.FromProtobuf(proto.scroll_tree(), &scroll_id_to_index_map);
 
   needs_rebuild = proto.needs_rebuild();
   changed = proto.changed();
   full_tree_damaged = proto.full_tree_damaged();
   non_root_surfaces_enabled = proto.non_root_surfaces_enabled();
   sequence_number = proto.sequence_number();
   is_main_thread = proto.is_main_thread();
   is_active = proto.is_active();
 
   transform_tree.SetPropertyTrees(this);
@@ skipping 95 matching lines @@
   value->EndDictionary();
 
   value->BeginDictionary("scroll_tree");
   scroll_tree.AsValueInto(value.get());
   value->EndDictionary();
 
   return value;
 }
 
 }  // namespace cc