cc: Stop creating unused 0 property tree nodes other than transform

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/clip_node.h"
@@ skipping 41 matching lines @@
 
   proto::TreeNode proto;
   original.ToProtobuf(&proto);
   TransformNode result;
   result.FromProtobuf(proto);
 
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, TransformTreeSerialization) {
-  PropertyTrees property_trees;
-  TransformTree& original = property_trees.transform_tree;
-  TransformNode& root = *original.Node(0);
-  root.id = 0;
+  TransformTree original;
+  TransformNode root;
   root.owner_id = 1;
-  original.SetTargetId(root.id, 3);
-  original.SetContentTargetId(root.id, 4);
+  root.id = original.Insert(root, TransformTree::kDeviceNodeId);
+  original.SetTargetId(root.id, TransformTree::kDeviceNodeId);
+  original.SetContentTargetId(root.id, TransformTree::kDeviceNodeId);
   TransformNode second;
   second.owner_id = 2;
   second.local.Translate3d(2.f, 2.f, 0.f);
-  second.source_node_id = 0;
-  second.id = original.Insert(second, 0);
-  original.SetTargetId(second.id, 0);
+  second.source_node_id = root.id;
+  second.id = original.Insert(second, root.id);
+  original.SetTargetId(second.id, root.id);
   TransformNode third;
   third.owner_id = 3;
   third.scrolls = true;
-  third.source_node_id = 1;
-  third.id = original.Insert(third, 1);
-  original.SetTargetId(third.id, 0);
+  third.source_node_id = root.id;
+  third.id = original.Insert(third, root.id);
+  original.SetTargetId(third.id, root.id);
 
   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;
   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(1, transform_id_to_index_map[1]);
+  EXPECT_EQ(2, transform_id_to_index_map[2]);
+  EXPECT_EQ(3, transform_id_to_index_map[3]);
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, ClipNodeSerialization) {
   ClipNode original;
   original.id = 3;
   original.parent_id = 2;
   original.owner_id = 4;
   original.clip = gfx::RectF(0.5f, 0.5f);
   original.combined_clip_in_target_space = gfx::RectF(0.6f, 0.6f);
@@ skipping 11 matching lines @@
   proto::TreeNode proto;
   original.ToProtobuf(&proto);
   ClipNode result;
   result.FromProtobuf(proto);
 
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, ClipTreeSerialization) {
   ClipTree original;
-  ClipNode& root = *original.Node(0);
+  ClipNode root;
   root.owner_id = 1;
   root.transform_id = 2;
   root.target_transform_id = 1;
   root.target_effect_id = 1;
   ClipNode second;
   second.owner_id = 2;
   second.transform_id = 4;
   second.applies_local_clip = true;
   ClipNode third;
   third.owner_id = 3;
   third.target_transform_id = 3;
   third.target_effect_id = 2;
   third.target_is_clipped = false;
 
+  original.Insert(root, -1);
   original.Insert(second, 0);
   original.Insert(third, 1);
   original.set_needs_update(true);
 
   proto::PropertyTree proto;
   original.ToProtobuf(&proto);
   ClipTree result;
   std::unordered_map<int, int> clip_id_to_index_map;
   result.FromProtobuf(proto, &clip_id_to_index_map);
 
@@ skipping 21 matching lines @@
   proto::TreeNode proto;
   original.ToProtobuf(&proto);
   EffectNode result;
   result.FromProtobuf(proto);
 
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, EffectTreeSerialization) {
   EffectTree original;
-  EffectNode& root = *original.Node(0);
+  EffectNode root;
   root.owner_id = 5;
   root.transform_id = 2;
   root.clip_id = 1;
   EffectNode second;
   second.owner_id = 6;
   second.transform_id = 4;
   second.opacity = true;
   second.mask_layer_id = 32;
   EffectNode third;
   third.owner_id = 7;
   third.clip_id = 3;
   third.replica_layer_id = 44;
   third.replica_mask_layer_id = 45;
   third.has_render_surface = false;
 
+  original.Insert(root, -1);
   original.Insert(second, 0);
   original.Insert(third, 1);
   original.AddMaskOrReplicaLayerId(32);
   original.AddMaskOrReplicaLayerId(44);
   original.AddMaskOrReplicaLayerId(45);
   original.set_needs_update(true);
 
   proto::PropertyTree proto;
   original.ToProtobuf(&proto);
   EffectTree result;
@@ skipping 26 matching lines @@
   ScrollNode result;
   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 root;
+  original.Insert(root, -1);
   ScrollNode second;
   second.owner_id = 10;
   second.scrollable = true;
   second.bounds = gfx::Size(15, 15);
   ScrollNode third;
   third.owner_id = 20;
   third.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;
   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();
+  ScrollNode root2;
+  original.Insert(root, -1);
   original.set_currently_scrolling_node(0);
   original.SetScrollOffset(2, gfx::ScrollOffset(1, 2));
 
   proto::PropertyTree proto2;
   original.ToProtobuf(&proto2);
   result = ScrollTree();
   scroll_id_to_index_map.clear();
   result.FromProtobuf(proto2, &scroll_id_to_index_map);
 
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, PropertyTrees) {
   PropertyTrees original;
   TransformNode transform_node1 = TransformNode();
   transform_node1.owner_id = 10;
-  transform_node1.id = original.transform_tree.Insert(transform_node1, 0);
+  transform_node1.id = original.transform_tree.Insert(
+      transform_node1, TransformTree::kDeviceNodeId);
   TransformNode transform_node2 = TransformNode();
   transform_node2.owner_id = 20;
-  transform_node2.id = original.transform_tree.Insert(transform_node2, 1);
-  original.transform_id_to_index_map[10] = 1;
-  original.transform_id_to_index_map[20] = 2;
+  transform_node2.id =
+      original.transform_tree.Insert(transform_node2, transform_node1.id);
+  original.transform_id_to_index_map[10] = transform_node1.id;
+  original.transform_id_to_index_map[20] = transform_node2.id;
 
   ClipNode clip_node1 = ClipNode();
   clip_node1.owner_id = 10;
-  clip_node1.id = original.clip_tree.Insert(clip_node1, 0);
+  clip_node1.id =
+      original.clip_tree.Insert(clip_node1, ClipTree::kInvalidNodeId);
   ClipNode clip_node2 = ClipNode();
   clip_node2.owner_id = 22;
-  clip_node2.id = original.clip_tree.Insert(clip_node2, 1);
-  original.clip_id_to_index_map[10] = 1;
-  original.clip_id_to_index_map[22] = 2;
+  clip_node2.id = original.clip_tree.Insert(clip_node2, clip_node1.id);
+  original.clip_id_to_index_map[10] = clip_node1.id;
+  original.clip_id_to_index_map[22] = clip_node2.id;
 
   EffectNode effect_node1 = EffectNode();
   effect_node1.owner_id = 11;
-  effect_node1.id = original.effect_tree.Insert(effect_node1, 0);
+  effect_node1.id =
+      original.effect_tree.Insert(effect_node1, EffectTree::kInvalidNodeId);
   EffectNode effect_node2 = EffectNode();
   effect_node2.owner_id = 23;
-  effect_node2.id = original.effect_tree.Insert(effect_node2, 1);
-  original.effect_id_to_index_map[11] = 1;
-  original.effect_id_to_index_map[23] = 2;
+  effect_node2.id = original.effect_tree.Insert(effect_node2, effect_node1.id);
+  original.effect_id_to_index_map[11] = effect_node1.id;
+  original.effect_id_to_index_map[23] = effect_node2.id;
 
   ScrollNode scroll_node1 = ScrollNode();
   scroll_node1.owner_id = 10;
-  scroll_node1.id = original.scroll_tree.Insert(scroll_node1, 0);
+  scroll_node1.id =
+      original.scroll_tree.Insert(scroll_node1, ScrollTree::kInvalidNodeId);
   ScrollNode scroll_node2 = ScrollNode();
   scroll_node2.owner_id = 20;
-  scroll_node2.id = original.scroll_tree.Insert(scroll_node2, 1);
-  original.scroll_id_to_index_map[10] = 1;
-  original.scroll_id_to_index_map[20] = 2;
+  scroll_node2.id = original.scroll_tree.Insert(scroll_node2, scroll_node1.id);
+  original.scroll_id_to_index_map[10] = scroll_node1.id;
+  original.scroll_id_to_index_map[20] = scroll_node2.id;
 
   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);
 
@@ skipping 54 matching lines @@
 
 #define DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(TEST_FIXTURE_NAME) \
   DIRECT_PROPERTY_TREE_TEST_F(TEST_FIXTURE_NAME);                     \
   SERIALIZED_PROPERTY_TREE_TEST_F(TEST_FIXTURE_NAME)
 
 class PropertyTreeTestComputeTransformRoot : public PropertyTreeTest {
  protected:
   void StartTest() override {
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
-    TransformNode& root = *tree.Node(0);
-    root.id = 0;
+    TransformNode root;
     root.local.Translate(2, 2);
-    tree.SetTargetId(root.id, 0);
+    root.id = tree.Insert(root, TransformTree::kDeviceNodeId);
+    tree.SetTargetId(root.id, TransformTree::kDeviceNodeId);
     SetupTransformTreeForTest(&tree);
-    tree.UpdateTransforms(0);
+    tree.UpdateTransforms(root.id);
 
     gfx::Transform expected;
     gfx::Transform transform;
-    bool success = tree.ComputeTransform(0, 0, &transform);
+    bool success = tree.ComputeTransform(root.id, root.id, &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 
     transform.MakeIdentity();
     expected.Translate(2, 2);
-    success = tree.ComputeTransform(0, -1, &transform);
+    success = tree.ComputeTransform(root.id, TransformTree::kDeviceNodeId,
+                                    &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 
     transform.MakeIdentity();
     expected.MakeIdentity();
     expected.Translate(-2, -2);
-    success = tree.ComputeTransform(-1, 0, &transform);
+    success = tree.ComputeTransform(TransformTree::kDeviceNodeId, root.id,
+                                    &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestComputeTransformRoot);
 
 class PropertyTreeTestComputeTransformChild : public PropertyTreeTest {
  protected:
   void StartTest() override {
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
-    TransformNode& root = *tree.Node(0);
+    TransformNode root;
     root.local.Translate(2, 2);
-    tree.SetTargetId(root.id, 0);
-    tree.UpdateTransforms(0);
+    root.id = tree.Insert(root, TransformTree::kDeviceNodeId);
+    tree.SetTargetId(root.id, TransformTree::kDeviceNodeId);
+    tree.UpdateTransforms(root.id);
 
     TransformNode child;
     child.local.Translate(3, 3);
-    child.source_node_id = 0;
-    child.id = tree.Insert(child, 0);
-    tree.SetTargetId(child.id, 0);
+    child.source_node_id = root.id;
+    child.id = tree.Insert(child, root.id);
+    tree.SetTargetId(child.id, root.id);
 
     SetupTransformTreeForTest(&tree);
-    tree.UpdateTransforms(1);
+    tree.UpdateTransforms(child.id);
 
     gfx::Transform expected;
     gfx::Transform transform;
 
     expected.Translate(3, 3);
-    bool success = tree.ComputeTransform(1, 0, &transform);
+    bool success = tree.ComputeTransform(child.id, root.id, &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 
     transform.MakeIdentity();
     expected.MakeIdentity();
     expected.Translate(-3, -3);
-    success = tree.ComputeTransform(0, 1, &transform);
+    success = tree.ComputeTransform(root.id, child.id, &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 
     transform.MakeIdentity();
     expected.MakeIdentity();
     expected.Translate(5, 5);
-    success = tree.ComputeTransform(1, -1, &transform);
+    success = tree.ComputeTransform(child.id, TransformTree::kDeviceNodeId,
+                                    &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 
     transform.MakeIdentity();
     expected.MakeIdentity();
     expected.Translate(-5, -5);
-    success = tree.ComputeTransform(-1, 1, &transform);
+    success = tree.ComputeTransform(TransformTree::kDeviceNodeId, child.id,
+                                    &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestComputeTransformChild);
 
 class PropertyTreeTestComputeTransformSibling : public PropertyTreeTest {
  protected:
   void StartTest() override {
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
-    TransformNode& root = *tree.Node(0);
+    TransformNode root;
     root.local.Translate(2, 2);
-    tree.SetTargetId(root.id, 0);
-    tree.UpdateTransforms(0);
+    root.id = tree.Insert(root, TransformTree::kDeviceNodeId);
+    tree.SetTargetId(root.id, TransformTree::kDeviceNodeId);
+    tree.UpdateTransforms(root.id);
 
     TransformNode child;
     child.local.Translate(3, 3);
-    child.source_node_id = 0;
-    child.id = tree.Insert(child, 0);
-    tree.SetTargetId(child.id, 0);
+    child.source_node_id = root.id;
+    child.id = tree.Insert(child, root.id);
+    tree.SetTargetId(child.id, root.id);
 
     TransformNode sibling;
     sibling.local.Translate(7, 7);
-    sibling.source_node_id = 0;
-    sibling.id = tree.Insert(sibling, 0);
-    tree.SetTargetId(sibling.id, 0);
+    sibling.source_node_id = root.id;
+    sibling.id = tree.Insert(sibling, root.id);
+    tree.SetTargetId(sibling.id, root.id);
 
     SetupTransformTreeForTest(&tree);
 
-    tree.UpdateTransforms(1);
-    tree.UpdateTransforms(2);
+    tree.UpdateTransforms(child.id);
+    tree.UpdateTransforms(sibling.id);
 
     gfx::Transform expected;
     gfx::Transform transform;
 
     expected.Translate(4, 4);
-    bool success = tree.ComputeTransform(2, 1, &transform);
+    bool success = tree.ComputeTransform(sibling.id, child.id, &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 
     transform.MakeIdentity();
     expected.MakeIdentity();
     expected.Translate(-4, -4);
-    success = tree.ComputeTransform(1, 2, &transform);
+    success = tree.ComputeTransform(child.id, sibling.id, &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestComputeTransformSibling);
 
 class PropertyTreeTestComputeTransformSiblingSingularAncestor
     : public PropertyTreeTest {
  protected:
   void StartTest() override {
     // In this test, we have the following tree:
     // root
     //   + singular
     //     + child
     //     + sibling
     // Since the lowest common ancestor of |child| and |sibling| has a singular
     // transform, we cannot use screen space transforms to compute change of
     // basis
     // transforms between these nodes.
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
-    TransformNode& root = *tree.Node(0);
+    TransformNode root;
     root.local.Translate(2, 2);
-    tree.SetTargetId(root.id, 0);
-    tree.UpdateTransforms(0);
+    root.id = tree.Insert(root, TransformTree::kDeviceNodeId);
+    tree.SetTargetId(root.id, root.id);
+    tree.UpdateTransforms(root.id);
 
     TransformNode singular;
     singular.local.matrix().set(2, 2, 0.0);
-    singular.source_node_id = 0;
-    singular.id = tree.Insert(singular, 0);
-    tree.SetTargetId(singular.id, 0);
+    singular.source_node_id = root.id;
+    singular.id = tree.Insert(singular, root.id);
+    tree.SetTargetId(singular.id, root.id);
 
     TransformNode child;
     child.local.Translate(3, 3);
-    child.source_node_id = 1;
-    child.id = tree.Insert(child, 1);
-    tree.SetTargetId(child.id, 0);
+    child.source_node_id = singular.id;
+    child.id = tree.Insert(child, singular.id);
+    tree.SetTargetId(child.id, root.id);
 
     TransformNode sibling;
     sibling.local.Translate(7, 7);
-    sibling.source_node_id = 1;
-    sibling.id = tree.Insert(sibling, 1);
-    tree.SetTargetId(sibling.id, 0);
+    sibling.source_node_id = singular.id;
+    sibling.id = tree.Insert(sibling, singular.id);
+    tree.SetTargetId(sibling.id, root.id);
 
     SetupTransformTreeForTest(&tree);
 
-    tree.UpdateTransforms(1);
-    tree.UpdateTransforms(2);
-    tree.UpdateTransforms(3);
+    tree.UpdateTransforms(singular.id);
+    tree.UpdateTransforms(child.id);
+    tree.UpdateTransforms(sibling.id);
 
     gfx::Transform expected;
     gfx::Transform transform;
 
     expected.Translate(4, 4);
-    bool success = tree.ComputeTransform(3, 2, &transform);
+    bool success = tree.ComputeTransform(sibling.id, child.id, &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 
     transform.MakeIdentity();
     expected.MakeIdentity();
     expected.Translate(-4, -4);
-    success = tree.ComputeTransform(2, 3, &transform);
+    success = tree.ComputeTransform(child.id, sibling.id, &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestComputeTransformSiblingSingularAncestor);
 
 class PropertyTreeTestTransformsWithFlattening : public PropertyTreeTest {
  protected:
   void StartTest() override {
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
 
-    int grand_parent = tree.Insert(TransformNode(), 0);
+    int grand_parent =
+        tree.Insert(TransformNode(), TransformTree::kDeviceNodeId);
     tree.SetContentTargetId(grand_parent, grand_parent);
     tree.SetTargetId(grand_parent, grand_parent);
-    tree.Node(grand_parent)->source_node_id = 0;
+    tree.Node(grand_parent)->source_node_id = TransformTree::kDeviceNodeId;
 
     gfx::Transform rotation_about_x;
     rotation_about_x.RotateAboutXAxis(15);
 
     int parent = tree.Insert(TransformNode(), grand_parent);
     tree.Node(parent)->needs_sublayer_scale = true;
     tree.SetTargetId(parent, grand_parent);
     tree.SetContentTargetId(parent, parent);
     tree.Node(parent)->source_node_id = grand_parent;
     tree.Node(parent)->local = rotation_about_x;
@@ skipping 59 matching lines @@
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestTransformsWithFlattening);
 
 class PropertyTreeTestMultiplicationOrder : public PropertyTreeTest {
  protected:
   void StartTest() override {
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
-    TransformNode& root = *tree.Node(0);
+    TransformNode root;
     root.local.Translate(2, 2);
-    tree.SetTargetId(root.id, 0);
-    tree.UpdateTransforms(0);
+    root.id = tree.Insert(root, TransformTree::kDeviceNodeId);
+    tree.SetTargetId(root.id, TransformTree::kDeviceNodeId);
+    tree.UpdateTransforms(root.id);
 
     TransformNode child;
     child.local.Scale(2, 2);
-    child.source_node_id = 0;
-    child.id = tree.Insert(child, 0);
-    tree.SetTargetId(child.id, 0);
+    child.source_node_id = root.id;
+    child.id = tree.Insert(child, root.id);
+    tree.SetTargetId(child.id, root.id);
 
     SetupTransformTreeForTest(&tree);
-    tree.UpdateTransforms(1);
+    tree.UpdateTransforms(child.id);
 
     gfx::Transform expected;
     expected.Translate(2, 2);
     expected.Scale(2, 2);
 
     gfx::Transform transform;
     gfx::Transform inverse;
 
-    bool success = tree.ComputeTransform(1, -1, &transform);
+    bool success = tree.ComputeTransform(child.id, TransformTree::kDeviceNodeId,
+                                         &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 
-    success = tree.ComputeTransform(-1, 1, &inverse);
+    success =
+        tree.ComputeTransform(TransformTree::kDeviceNodeId, child.id, &inverse);
     EXPECT_TRUE(success);
 
     transform = transform * inverse;
     expected.MakeIdentity();
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(PropertyTreeTestMultiplicationOrder);
 
 class PropertyTreeTestComputeTransformWithUninvertibleTransform
     : public PropertyTreeTest {
  protected:
   void StartTest() override {
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
-    TransformNode& root = *tree.Node(0);
-    tree.SetTargetId(root.id, 0);
-    tree.UpdateTransforms(0);
+    TransformNode root;
+    root.id = tree.Insert(root, TransformTree::kDeviceNodeId);
+    tree.SetTargetId(root.id, TransformTree::kDeviceNodeId);
+    tree.UpdateTransforms(root.id);
 
     TransformNode child;
     child.local.Scale(0, 0);
-    child.source_node_id = 0;
-    child.id = tree.Insert(child, 0);
-    tree.SetTargetId(child.id, 0);
+    child.source_node_id = root.id;
+    child.id = tree.Insert(child, root.id);
+    tree.SetTargetId(child.id, root.id);
 
     SetupTransformTreeForTest(&tree);
-    tree.UpdateTransforms(1);
+    tree.UpdateTransforms(child.id);
 
     gfx::Transform expected;
     expected.Scale(0, 0);
 
     gfx::Transform transform;
     gfx::Transform inverse;
 
-    bool success = tree.ComputeTransform(1, 0, &transform);
+    bool success = tree.ComputeTransform(child.id, root.id, &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 
     // To compute this would require inverting the 0 matrix, so we cannot
     // succeed.
-    success = tree.ComputeTransform(0, 1, &inverse);
+    success = tree.ComputeTransform(root.id, child.id, &inverse);
     EXPECT_FALSE(success);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestComputeTransformWithUninvertibleTransform);
 
 class PropertyTreeTestComputeTransformWithSublayerScale
     : public PropertyTreeTest {
  protected:
   void StartTest() override {
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
-    TransformNode& root = *tree.Node(0);
-    root.id = 0;
-    tree.SetTargetId(root.id, 0);
-    tree.UpdateTransforms(0);
+    TransformNode root;
+    root.id = tree.Insert(root, TransformTree::kDeviceNodeId);
+    tree.SetTargetId(root.id, TransformTree::kDeviceNodeId);
+    tree.UpdateTransforms(root.id);
 
     TransformNode grand_parent;
     grand_parent.local.Scale(2.f, 2.f);
-    grand_parent.source_node_id = 0;
+    grand_parent.source_node_id = root.id;
     grand_parent.needs_sublayer_scale = true;
-    int grand_parent_id = tree.Insert(grand_parent, 0);
-    tree.SetTargetId(grand_parent_id, 0);
+    int grand_parent_id = tree.Insert(grand_parent, root.id);
+    tree.SetTargetId(grand_parent_id, root.id);
     tree.UpdateTransforms(grand_parent_id);
 
     TransformNode parent;
     parent.local.Translate(15.f, 15.f);
     parent.source_node_id = grand_parent_id;
     int parent_id = tree.Insert(parent, grand_parent_id);
     tree.SetTargetId(parent_id, grand_parent_id);
     tree.UpdateTransforms(parent_id);
 
     TransformNode child;
@@ skipping 88 matching lines @@
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestComputeTransformWithSublayerScale);
 
 class PropertyTreeTestComputeTransformToTargetWithZeroSublayerScale
     : public PropertyTreeTest {
  protected:
   void StartTest() override {
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
-    TransformNode& root = *tree.Node(0);
-    tree.SetTargetId(root.id, 0);
-    tree.UpdateTransforms(0);
+    TransformNode root;
+    root.id = tree.Insert(root, TransformTree::kDeviceNodeId);
+    tree.SetTargetId(root.id, TransformTree::kDeviceNodeId);
+    tree.UpdateTransforms(root.id);
 
     TransformNode grand_parent;
     grand_parent.local.Scale(2.f, 0.f);
-    grand_parent.source_node_id = 0;
+    grand_parent.source_node_id = root.id;
     grand_parent.needs_sublayer_scale = true;
-    int grand_parent_id = tree.Insert(grand_parent, 0);
-    tree.SetTargetId(grand_parent_id, 0);
+    int grand_parent_id = tree.Insert(grand_parent, root.id);
+    tree.SetTargetId(grand_parent_id, root.id);
     tree.SetContentTargetId(grand_parent_id, grand_parent_id);
     tree.UpdateTransforms(grand_parent_id);
 
     TransformNode parent;
     parent.local.Translate(1.f, 1.f);
     parent.source_node_id = grand_parent_id;
     int parent_id = tree.Insert(parent, grand_parent_id);
     tree.SetTargetId(parent_id, grand_parent_id);
     tree.SetContentTargetId(parent_id, grand_parent_id);
     tree.UpdateTransforms(parent_id);
@@ skipping 47 matching lines @@
 class PropertyTreeTestFlatteningWhenDestinationHasOnlyFlatAncestors
     : public PropertyTreeTest {
  protected:
   void StartTest() override {
     // This tests that flattening is performed correctly when
     // destination and its ancestors are flat, but there are 3d transforms
     // and flattening between the source and destination.
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
 
-    int parent = tree.Insert(TransformNode(), 0);
+    int parent = tree.Insert(TransformNode(), TransformTree::kDeviceNodeId);
     tree.SetContentTargetId(parent, parent);
     tree.SetTargetId(parent, parent);
-    tree.Node(parent)->source_node_id = 0;
+    tree.Node(parent)->source_node_id = TransformTree::kDeviceNodeId;
     tree.Node(parent)->local.Translate(2, 2);
 
     gfx::Transform rotation_about_x;
     rotation_about_x.RotateAboutXAxis(15);
 
     int child = tree.Insert(TransformNode(), parent);
     tree.SetContentTargetId(child, child);
     tree.SetTargetId(child, child);
     tree.Node(child)->source_node_id = parent;
     tree.Node(child)->local = rotation_about_x;
@@ skipping 23 matching lines @@
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestFlatteningWhenDestinationHasOnlyFlatAncestors);
 
 class PropertyTreeTestScreenSpaceOpacityUpdateTest : public PropertyTreeTest {
  protected:
   void StartTest() override {
     // This tests that screen space opacity is updated for the subtree when
     // opacity of a node changes.
     EffectTree tree;
 
-    int parent = tree.Insert(EffectNode(), 0);
+    int parent = tree.Insert(EffectNode(), EffectTree::kInvalidNodeId);
     int child = tree.Insert(EffectNode(), parent);
     SetupEffectTreeForTest(&tree);
 
     EXPECT_EQ(tree.Node(child)->screen_space_opacity, 1.f);
     tree.Node(parent)->opacity = 0.5f;
     tree.set_needs_update(true);
     SetupEffectTreeForTest(&tree);
     draw_property_utils::ComputeEffects(&tree);
     EXPECT_EQ(tree.Node(child)->screen_space_opacity, 0.5f);
 
     tree.Node(child)->opacity = 0.5f;
     tree.set_needs_update(true);
     SetupEffectTreeForTest(&tree);
     draw_property_utils::ComputeEffects(&tree);
     EXPECT_EQ(tree.Node(child)->screen_space_opacity, 0.25f);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestScreenSpaceOpacityUpdateTest);
 
 class PropertyTreeTestNonIntegerTranslationTest : public PropertyTreeTest {
  protected:
   void StartTest() override {
     // This tests that when a node has non-integer translation, the information
     // is propagated to the subtree.
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
 
-    int parent = tree.Insert(TransformNode(), 0);
+    int parent = tree.Insert(TransformNode(), TransformTree::kDeviceNodeId);
     tree.SetTargetId(parent, parent);
     tree.Node(parent)->local.Translate(1.5f, 1.5f);
 
     int child = tree.Insert(TransformNode(), parent);
     tree.SetTargetId(child, parent);
     tree.Node(child)->local.Translate(1, 1);
     tree.set_needs_update(true);
     SetupTransformTreeForTest(&tree);
     draw_property_utils::ComputeTransforms(&tree);
     EXPECT_FALSE(
@@ skipping 27 matching lines @@
     PropertyTreeTestNonIntegerTranslationTest);
 
 class PropertyTreeTestSingularTransformSnapTest : public PropertyTreeTest {
  protected:
   void StartTest() override {
     // This tests that to_target transform is not snapped when it has a singular
     // transform.
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
 
-    int parent = tree.Insert(TransformNode(), 0);
+    int parent = tree.Insert(TransformNode(), TransformTree::kDeviceNodeId);
     tree.SetTargetId(parent, parent);
     tree.Node(parent)->scrolls = true;
 
     int child = tree.Insert(TransformNode(), parent);
     TransformNode* child_node = tree.Node(child);
     tree.SetTargetId(child, parent);
     child_node->scrolls = true;
     child_node->local.Scale3d(6.0f, 6.0f, 0.0f);
     child_node->local.Translate(1.3f, 1.3f);
     tree.set_needs_update(true);
@@ skipping 19 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