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

cc/trees/property_tree.cc

Index: cc/trees/property_tree.cc
diff --git a/cc/trees/property_tree.cc b/cc/trees/property_tree.cc
index d2b3783a5724dc82c0c44fadb6e5c24e3e3b5279..1fdb436c840423e9b6935907b4b66cb328957f73 100644
--- a/cc/trees/property_tree.cc
+++ b/cc/trees/property_tree.cc
@@ -29,9 +29,6 @@ namespace cc {
 template <typename T>
 PropertyTree<T>::PropertyTree()
     : needs_update_(false) {
-  nodes_.push_back(T());
-  back()->id = 0;
-  back()->parent_id = -1;
 }
 
 // Equivalent to
@@ -49,7 +46,7 @@ TransformTree::TransformTree()
       page_scale_factor_(1.f),
       device_scale_factor_(1.f),
       device_transform_scale_factor_(1.f) {
-  cached_data_.push_back(TransformCachedNodeData());
+  Insert(TransformNode(), kInvalidNodeId);
 }
 
 TransformTree::~TransformTree() = default;
@@ -57,7 +54,9 @@ TransformTree& TransformTree::operator=(const TransformTree&) = default;
 
 template <typename T>
 int PropertyTree<T>::Insert(const T& tree_node, int parent_id) {
-  DCHECK_GT(nodes_.size(), 0u);
+  if (nodes_.size() == 0u)
+    DCHECK_EQ(parent_id, kInvalidNodeId) << "size" << nodes_.size()
+                                         << "parentid" << parent_id;
   nodes_.push_back(tree_node);
   T& node = nodes_.back();
   node.parent_id = parent_id;
@@ -68,9 +67,6 @@ int PropertyTree<T>::Insert(const T& tree_node, int parent_id) {
 template <typename T>
 void PropertyTree<T>::clear() {
   nodes_.clear();
-  nodes_.push_back(T());
-  back()->id = 0;
-  back()->parent_id = -1;
 }
 
 template <typename T>
@@ -90,17 +86,12 @@ template <typename T>
 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_GE(proto.nodes_size(), 0);
+  nodes_.clear();
 
-  DCHECK(!node_id_to_index_map || (*node_id_to_index_map).empty());
-  for (int i = 1; i < proto.nodes_size(); ++i) {
+  node_id_to_index_map->clear();
+  for (int i = 0; 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;
@@ -127,9 +118,9 @@ template class PropertyTree<ScrollNode>;
 
 int TransformTree::Insert(const TransformNode& tree_node, int parent_id) {
   int node_id = PropertyTree<TransformNode>::Insert(tree_node, parent_id);
-  DCHECK_EQ(node_id, static_cast<int>(cached_data_.size()));
-
   cached_data_.push_back(TransformCachedNodeData());
+  DCHECK_EQ(size(), cached_data_.size());
+
   return node_id;
 }
 
@@ -139,7 +130,7 @@ void TransformTree::clear() {
   nodes_affected_by_inner_viewport_bounds_delta_.clear();
   nodes_affected_by_outer_viewport_bounds_delta_.clear();
   cached_data_.clear();
-  cached_data_.push_back(TransformCachedNodeData());
+  Insert(TransformNode(), TransformTree::kInvalidNodeId);
 }
 
 bool TransformTree::ComputeTransform(int source_id,
@@ -203,7 +194,8 @@ bool TransformTree::NeedsSourceToParentUpdate(TransformNode* node) {
 }
 
 void TransformTree::ResetChangeTracking() {
-  for (int id = 1; id < static_cast<int>(size()); ++id) {
+  for (int id = TransformTree::kDeviceNodeId; id < static_cast<int>(size());
+       ++id) {
     TransformNode* node = Node(id);
     node->transform_changed = false;
   }
@@ -435,6 +427,8 @@ void TransformTree::UpdateSublayerScale(TransformNode* node) {
 
 void TransformTree::UpdateTargetSpaceTransform(TransformNode* node,
                                                TransformNode* target_node) {
+  DCHECK(node);
+  DCHECK(target_node);
   gfx::Transform target_space_transform;
   if (node->needs_sublayer_scale) {
     target_space_transform.MakeIdentity();
@@ -542,7 +536,7 @@ void TransformTree::UpdateNodeAndAncestorsAreAnimatedOrInvertible(
 void TransformTree::SetDeviceTransform(const gfx::Transform& transform,
                                        gfx::PointF root_position) {
   gfx::Transform root_post_local = transform;
-  TransformNode* node = Node(1);
+  TransformNode* node = Node(TransformTree::kRootNodeId);
   root_post_local.Scale(node->post_local_scale_factor,
                         node->post_local_scale_factor);
   root_post_local.Translate(root_position.x(), root_position.y());
@@ -647,7 +641,11 @@ int TransformTree::TargetId(int node_id) const {
 }
 
 void TransformTree::SetTargetId(int node_id, int target_id) {
-  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
+  DCHECK(static_cast<int>(cached_data_.size()) > node_id) << node_id;
+  DCHECK(static_cast<int>(size()) > target_id) << target_id << " v.s. "
+                                               << size();
+  DCHECK_GE(target_id, TransformTree::kDeviceNodeId) << target_id;
+  DCHECK_LE(target_id, node_id) << target_id << " v.s. " << node_id;
   cached_data_[node_id].target_id = target_id;
 }
 
@@ -663,8 +661,8 @@ void TransformTree::SetContentTargetId(int node_id, int content_target_id) {
 
 gfx::Transform TransformTree::ToScreenSpaceTransformWithoutSublayerScale(
     int id) const {
-  DCHECK_GT(id, 0);
-  if (id == 1) {
+  DCHECK_GE(id, TransformTree::kRootNodeId);
+  if (id == TransformTree::kRootNodeId) {
     return gfx::Transform();
   }
   const TransformNode* node = Node(id);
@@ -717,6 +715,8 @@ void TransformTree::FromProtobuf(
     std::unordered_map<int, int>* node_id_to_index_map) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Transform);
+  // Verify that the property tree is empty.
+  DCHECK_EQ(static_cast<int>(size()), TransformTree::kRootNodeId);
 
   PropertyTree::FromProtobuf(proto, node_id_to_index_map);
   const proto::TransformTreeData& data = proto.transform_tree_data();
@@ -739,10 +739,10 @@ void TransformTree::FromProtobuf(
     nodes_affected_by_outer_viewport_bounds_delta_.push_back(
         data.nodes_affected_by_outer_viewport_bounds_delta(i));
   }
-
   DCHECK_EQ(static_cast<int>(cached_data_.size()), 1);
-  cached_data_.back().FromProtobuf(data.cached_data(0));
-  for (int i = 1; i < data.cached_data_size(); ++i) {
+  cached_data_.clear();
+  // cached_data_.back().FromProtobuf(data.cached_data(0));
+  for (int i = 0; i < data.cached_data_size(); ++i) {
     cached_data_.push_back(TransformCachedNodeData());
     cached_data_.back().FromProtobuf(data.cached_data(i));
   }
@@ -914,7 +914,7 @@ void EffectTree::TakeCopyRequestsAndTransformToSurface(
     // the surface to the space of the surface itself.
     int destination_id = effect_node->transform_id;
     int source_id;
-    if (effect_node->parent_id != -1) {
+    if (effect_node->parent_id != EffectTree::kInvalidNodeId) {
       // For non-root surfaces, transform only by sub-layer scale.
       source_id = destination_id;
     } else {
@@ -949,19 +949,16 @@ void EffectTree::ClearCopyRequests() {
 }
 
 int EffectTree::ClosestAncestorWithCopyRequest(int id) const {
-  DCHECK_GE(id, 0);
+  DCHECK_GE(id, EffectTree::kRootNodeId);
   const EffectNode* node = Node(id);
-  while (node->id > 1) {
+  while (node) {
     if (node->has_copy_request)
       return node->id;
 
     node = parent(node);
   }
 
-  if (node->has_copy_request)
-    return node->id;
-  else
-    return -1;
+  return EffectTree::kInvalidNodeId;
 }
 
 void EffectTree::AddMaskOrReplicaLayerId(int id) {
@@ -978,7 +975,7 @@ bool EffectTree::ContributesToDrawnSurface(int id) {
 }
 
 void EffectTree::ResetChangeTracking() {
-  for (int id = 1; id < static_cast<int>(size()); ++id) {
+  for (int id = EffectTree::kRootNodeId; id < static_cast<int>(size()); ++id) {
     EffectNode* node = Node(id);
     node->effect_changed = false;
   }
@@ -998,7 +995,7 @@ void TransformTree::UpdateNodeAndAncestorsHaveIntegerTranslations(
 void ClipTree::SetViewportClip(gfx::RectF viewport_rect) {
   if (size() < 2)
     return;
-  ClipNode* node = Node(1);
+  ClipNode* node = Node(ClipTree::kViewportNodeId);
   if (viewport_rect == node->clip)
     return;
   node->clip = viewport_rect;
@@ -1008,7 +1005,7 @@ void ClipTree::SetViewportClip(gfx::RectF viewport_rect) {
 gfx::RectF ClipTree::ViewportClip() {
   const unsigned long min_size = 1;
   DCHECK_GT(size(), min_size);
-  return Node(1)->clip;
+  return Node(ClipTree::kViewportNodeId)->clip;
 }
 
 bool ClipTree::operator==(const ClipTree& other) const {
@@ -1027,6 +1024,8 @@ void ClipTree::FromProtobuf(
     std::unordered_map<int, int>* node_id_to_index_map) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Clip);
+  // Verify that the property tree is empty.
+  DCHECK_EQ(static_cast<int>(size()), ClipTree::kRootNodeId);
 
   PropertyTree::FromProtobuf(proto, node_id_to_index_map);
 }
@@ -1060,6 +1059,8 @@ void EffectTree::FromProtobuf(
     std::unordered_map<int, int>* node_id_to_index_map) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Effect);
+  // Verify that the property tree is empty.
+  DCHECK_EQ(static_cast<int>(size()), EffectTree::kRootNodeId);
 
   PropertyTree::FromProtobuf(proto, node_id_to_index_map);
   const proto::EffectTreeData& data = proto.effect_tree_data();
@@ -1135,6 +1136,8 @@ void ScrollTree::FromProtobuf(
     std::unordered_map<int, int>* node_id_to_index_map) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Scroll);
+  // Verify that the property tree is empty.
+  DCHECK_EQ(static_cast<int>(size()), ScrollTree::kRootNodeId);
 
   PropertyTree::FromProtobuf(proto, node_id_to_index_map);
   const proto::ScrollTreeData& data = proto.scroll_tree_data();
@@ -1494,6 +1497,7 @@ PropertyTrees::PropertyTrees()
   effect_tree.SetPropertyTrees(this);
   clip_tree.SetPropertyTrees(this);
   scroll_tree.SetPropertyTrees(this);
+  transform_id_to_index_map[Layer::INVALID_ID] = TransformTree::kDeviceNodeId;
 }
 
 PropertyTrees::~PropertyTrees() {}
@@ -1661,12 +1665,14 @@ bool PropertyTrees::IsInIdToIndexMap(TreeType tree_type, int id) {
 }
 
 void PropertyTrees::UpdateChangeTracking() {
-  for (int id = 1; id < static_cast<int>(effect_tree.size()); ++id) {
+  for (int id = EffectTree::kRootNodeId;
+       id < static_cast<int>(effect_tree.size()); ++id) {
     EffectNode* node = effect_tree.Node(id);
     EffectNode* parent_node = effect_tree.parent(node);
     effect_tree.UpdateEffectChanged(node, parent_node);
   }
-  for (int i = 1; i < static_cast<int>(transform_tree.size()); ++i) {
+  for (int i = TransformTree::kRootNodeId;
+       i < static_cast<int>(transform_tree.size()); ++i) {
     TransformNode* node = transform_tree.Node(i);
     TransformNode* parent_node = transform_tree.parent(node);
     TransformNode* source_node = transform_tree.Node(node->source_node_id);
@@ -1675,14 +1681,16 @@ void PropertyTrees::UpdateChangeTracking() {
 }
 
 void PropertyTrees::PushChangeTrackingTo(PropertyTrees* tree) {
-  for (int id = 1; id < static_cast<int>(effect_tree.size()); ++id) {
+  for (int id = EffectTree::kRootNodeId;
+       id < static_cast<int>(effect_tree.size()); ++id) {
     EffectNode* node = effect_tree.Node(id);
     if (node->effect_changed) {
       EffectNode* target_node = tree->effect_tree.Node(node->id);
       target_node->effect_changed = true;
     }
   }
-  for (int id = 1; id < static_cast<int>(transform_tree.size()); ++id) {
+  for (int id = TransformTree::kRootNodeId;
+       id < static_cast<int>(transform_tree.size()); ++id) {
     TransformNode* node = transform_tree.Node(id);
     if (node->transform_changed) {
       TransformNode* target_node = tree->transform_tree.Node(node->id);