cc : Add LayerToPropertyTreeIndices map to PropertyTrees

cc/trees/property_tree_unittest.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.h"
 
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/proto/property_tree.pb.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/trees/draw_property_utils.h"
@@ skipping 61 matching lines @@
   original.ToProtobuf(&proto);
   TransformNode result;
   result.FromProtobuf(proto);
 
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, TransformTreeSerialization) {
   TransformTree original;
   TransformNode& root = *original.Node(0);
+  root.owner_id = 1;
   root.data.target_id = 3;
   root.data.content_target_id = 4;
   TransformNode second;
+  second.owner_id = 2;
   second.data.local.Translate3d(2.f, 2.f, 0.f);
   second.data.source_node_id = 0;
   second.data.target_id = 0;
   TransformNode third;
+  third.owner_id = 3;
   third.data.scrolls = true;
   third.data.source_node_id = 1;
   third.data.target_id = 0;
 
   original.Insert(second, 0);
   original.Insert(third, 1);
   original.set_needs_update(true);
 
   original.set_page_scale_factor(0.5f);
   original.set_device_scale_factor(0.6f);
   gfx::Transform transform =
       gfx::Transform(1.05f, 2.15f, 3.14f, 4.13f, 5.12f, 6.11f, 7.1f, 8.9f, 9.8f,
                      10.7f, 11.6f, 12.5f, 13.4f, 14.3f, 15.2f, 16.1f);
   original.SetDeviceTransformScaleFactor(transform);
   original.AddNodeAffectedByInnerViewportBoundsDelta(0);
   original.AddNodeAffectedByOuterViewportBoundsDelta(1);
 
   proto::PropertyTree proto;
   original.ToProtobuf(&proto);
   TransformTree result;
-  result.FromProtobuf(proto);
+  std::unordered_map<int, int> transform_id_to_index_map;
+  result.FromProtobuf(proto, &transform_id_to_index_map);
 
+  EXPECT_EQ(transform_id_to_index_map[1], 0);
+  EXPECT_EQ(transform_id_to_index_map[2], 1);
+  EXPECT_EQ(transform_id_to_index_map[3], 2);
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, ClipNodeDataSerialization) {
   ClipNodeData original;
   original.clip = gfx::RectF(0.5f, 0.5f);
   original.combined_clip_in_target_space = gfx::RectF(0.6f, 0.6f);
   original.clip_in_target_space = gfx::RectF(0.7f, 0.7f);
   original.transform_id = 2;
   original.target_id = 3;
@@ skipping 22 matching lines @@
   original.ToProtobuf(&proto);
   ClipNode result;
   result.FromProtobuf(proto);
 
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, ClipTreeSerialization) {
   ClipTree original;
   ClipNode& root = *original.Node(0);
+  root.owner_id = 1;
   root.data.transform_id = 2;
   root.data.target_id = 1;
   ClipNode second;
+  second.owner_id = 2;
   second.data.transform_id = 4;
   second.data.applies_local_clip = true;
   ClipNode third;
+  third.owner_id = 3;
   third.data.target_id = 3;
   third.data.target_is_clipped = false;
 
   original.Insert(second, 0);
   original.Insert(third, 1);
   original.set_needs_update(true);
 
   proto::PropertyTree proto;
   original.ToProtobuf(&proto);
   ClipTree result;
-  result.FromProtobuf(proto);
+  std::unordered_map<int, int> clip_id_to_index_map;
+  result.FromProtobuf(proto, &clip_id_to_index_map);
 
+  EXPECT_EQ(clip_id_to_index_map[1], 0);
+  EXPECT_EQ(clip_id_to_index_map[2], 1);
+  EXPECT_EQ(clip_id_to_index_map[3], 2);
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, EffectNodeDataSerialization) {
   EffectNodeData original;
   original.opacity = 0.5f;
   original.screen_space_opacity = 0.6f;
   original.has_render_surface = false;
   original.transform_id = 2;
   original.clip_id = 3;
@@ skipping 16 matching lines @@
   original.ToProtobuf(&proto);
   EffectNode result;
   result.FromProtobuf(proto);
 
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, EffectTreeSerialization) {
   EffectTree original;
   EffectNode& root = *original.Node(0);
+  root.owner_id = 5;
   root.data.transform_id = 2;
   root.data.clip_id = 1;
   EffectNode second;
+  second.owner_id = 6;
   second.data.transform_id = 4;
   second.data.opacity = true;
   EffectNode third;
+  third.owner_id = 7;
   third.data.clip_id = 3;
   third.data.has_render_surface = false;
 
   original.Insert(second, 0);
   original.Insert(third, 1);
   original.set_needs_update(true);
 
   proto::PropertyTree proto;
   original.ToProtobuf(&proto);
   EffectTree result;
-  result.FromProtobuf(proto);
+  std::unordered_map<int, int> effect_id_to_index_map;
+  result.FromProtobuf(proto, &effect_id_to_index_map);
 
+  EXPECT_EQ(effect_id_to_index_map[5], 0);
+  EXPECT_EQ(effect_id_to_index_map[6], 1);
+  EXPECT_EQ(effect_id_to_index_map[7], 2);
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, ScrollNodeDataSerialization) {
   ScrollNodeData original;
   original.scrollable = true;
   original.main_thread_scrolling_reasons =
       MainThreadScrollingReason::kScrollbarScrolling;
   original.contains_non_fast_scrollable_region = false;
   original.scroll_clip_layer_bounds = gfx::Size(10, 10);
@@ skipping 22 matching lines @@
   result.FromProtobuf(proto);
 
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, ScrollTreeSerialization) {
   PropertyTrees property_trees;
   property_trees.is_main_thread = true;
   ScrollTree& original = property_trees.scroll_tree;
   ScrollNode second;
+  second.owner_id = 10;
   second.data.scrollable = true;
   second.data.bounds = gfx::Size(15, 15);
   ScrollNode third;
+  third.owner_id = 20;
   third.data.contains_non_fast_scrollable_region = true;
 
   original.Insert(second, 0);
   original.Insert(third, 1);
 
   original.set_currently_scrolling_node(1);
   original.SetScrollOffset(1, gfx::ScrollOffset(1, 2));
 
   proto::PropertyTree proto;
   original.ToProtobuf(&proto);
   ScrollTree result;
-  result.FromProtobuf(proto);
+  std::unordered_map<int, int> scroll_id_to_index_map;
+  result.FromProtobuf(proto, &scroll_id_to_index_map);
 
   EXPECT_EQ(original, result);
+  EXPECT_EQ(scroll_id_to_index_map[10], 1);
+  EXPECT_EQ(scroll_id_to_index_map[20], 2);
 
   original.clear();
   original.set_currently_scrolling_node(0);
   original.SetScrollOffset(2, gfx::ScrollOffset(1, 2));
 
   proto::PropertyTree proto2;
   original.ToProtobuf(&proto2);
   result = ScrollTree();
-  result.FromProtobuf(proto2);
+  scroll_id_to_index_map.clear();
+  result.FromProtobuf(proto2, &scroll_id_to_index_map);
 
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, PropertyTrees) {
   PropertyTrees original;
-  original.transform_tree.Insert(TransformNode(), 0);
-  original.transform_tree.Insert(TransformNode(), 1);
-  original.clip_tree.Insert(ClipNode(), 0);
-  original.clip_tree.Insert(ClipNode(), 1);
-  original.effect_tree.Insert(EffectNode(), 0);
-  original.effect_tree.Insert(EffectNode(), 1);
-  original.scroll_tree.Insert(ScrollNode(), 0);
-  original.scroll_tree.Insert(ScrollNode(), 1);
+  TransformNode transform_node1 = TransformNode();
+  transform_node1.owner_id = 10;
+  original.transform_tree.Insert(transform_node1, 0);
+  TransformNode transform_node2 = TransformNode();
+  transform_node2.owner_id = 20;
+  original.transform_tree.Insert(transform_node2, 1);
+  original.transform_id_to_index_map[10] = 1;
+  original.transform_id_to_index_map[20] = 2;
+
+  ClipNode clip_node1 = ClipNode();
+  clip_node1.owner_id = 10;
+  original.clip_tree.Insert(clip_node1, 0);
+  ClipNode clip_node2 = ClipNode();
+  clip_node2.owner_id = 22;
+  original.clip_tree.Insert(clip_node2, 1);
+  original.clip_id_to_index_map[10] = 1;
+  original.clip_id_to_index_map[22] = 2;
+
+  EffectNode effect_node1 = EffectNode();
+  effect_node1.owner_id = 11;
+  original.effect_tree.Insert(effect_node1, 0);
+  EffectNode effect_node2 = EffectNode();
+  effect_node2.owner_id = 23;
+  original.effect_tree.Insert(effect_node2, 1);
+  original.effect_id_to_index_map[11] = 1;
+  original.effect_id_to_index_map[23] = 2;
+
+  ScrollNode scroll_node1 = ScrollNode();
+  scroll_node1.owner_id = 10;
+  original.scroll_tree.Insert(scroll_node1, 0);
+  ScrollNode scroll_node2 = ScrollNode();
+  scroll_node2.owner_id = 20;
+  original.scroll_tree.Insert(scroll_node2, 1);
+  original.scroll_id_to_index_map[10] = 1;
+  original.scroll_id_to_index_map[20] = 2;
+
   original.needs_rebuild = false;
   original.non_root_surfaces_enabled = false;
   original.sequence_number = 3;
 
   proto::PropertyTrees proto;
   original.ToProtobuf(&proto);
   PropertyTrees result;
   result.FromProtobuf(proto);
 
   EXPECT_EQ(original, result);
@@ skipping 11 matching lines @@
 
   virtual void StartTest() = 0;
 
   TransformTree TransformTreeForTest(const TransformTree& transform_tree) {
     if (!test_serialization_) {
       return transform_tree;
     }
     TransformTree new_tree;
     proto::PropertyTree proto;
     transform_tree.ToProtobuf(&proto);
-    new_tree.FromProtobuf(proto);
+    std::unordered_map<int, int> transform_id_to_index_map;
+    new_tree.FromProtobuf(proto, &transform_id_to_index_map);
 
     new_tree.SetPropertyTrees(transform_tree.property_trees());
 
     EXPECT_EQ(transform_tree, new_tree);
     return new_tree;
   }
 
   EffectTree EffectTreeForTest(const EffectTree& effect_tree) {
     if (!test_serialization_) {
       return effect_tree;
     }
     EffectTree new_tree;
     proto::PropertyTree proto;
     effect_tree.ToProtobuf(&proto);
-    new_tree.FromProtobuf(proto);
+    std::unordered_map<int, int> effect_id_to_index_map;
+    new_tree.FromProtobuf(proto, &effect_id_to_index_map);
 
     EXPECT_EQ(effect_tree, new_tree);
     return new_tree;
   }
 
  private:
   bool test_serialization_;
 };
 
 #define DIRECT_PROPERTY_TREE_TEST_F(TEST_FIXTURE_NAME) \
@@ skipping 732 matching lines @@
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestSingularTransformSnapTest);
 
 #undef DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F
 #undef SERIALIZED_PROPERTY_TREE_TEST_F
 #undef DIRECT_PROPERTY_TREE_TEST_F
 
 }  // namespace
 }  // namespace cc