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

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 11 matching lines @@
 #include "cc/trees/property_tree.h"
 #include "cc/trees/scroll_node.h"
 #include "cc/trees/transform_node.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 
 template <typename T>
 PropertyTree<T>::PropertyTree()
     : needs_update_(false) {
-  nodes_.push_back(T());
-  back()->id = 0;
-  back()->parent_id = -1;
 }
 
 // Equivalent to
 // PropertyTree<T>::~PropertyTree() = default;
 // but due to a gcc bug the generated destructor will have wrong symbol
 // visibility in component build.
 template <typename T>
 PropertyTree<T>::~PropertyTree() {}
 
 template <typename T>
 PropertyTree<T>& PropertyTree<T>::operator=(const PropertyTree<T>&) = default;
 
 TransformTree::TransformTree()
     : source_to_parent_updates_allowed_(true),
       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;
 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;
   node.id = static_cast<int>(nodes_.size()) - 1;
   return node.id;
 }
 
 template <typename T>
 void PropertyTree<T>::clear() {
   nodes_.clear();
-  nodes_.push_back(T());
-  back()->id = 0;
-  back()->parent_id = -1;
 }
 
 template <typename T>
 bool PropertyTree<T>::operator==(const PropertyTree<T>& other) const {
   return nodes_ == other.nodes() && needs_update_ == other.needs_update();
 }
 
 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,
     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_GE(proto.nodes_size(), 0);
+  nodes_.clear();
 
-  // 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) {
+  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;
   }
 
   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();
     node.AsValueInto(value);
     value->EndDictionary();
   }
   value->EndArray();
 }
 
 template class PropertyTree<TransformNode>;
 template class PropertyTree<ClipNode>;
 template class PropertyTree<EffectNode>;
 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());
 
-  cached_data_.push_back(TransformCachedNodeData());
   return node_id;
 }
 
 void TransformTree::clear() {
   PropertyTree<TransformNode>::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,
                                      int dest_id,
                                      gfx::Transform* transform) const {
   transform->MakeIdentity();
 
   if (source_id == dest_id)
     return true;
 
@@ skipping 43 matching lines @@
   return ComputeTransform(source_id, dest_id, &transform) &&
          transform.Preserves2dAxisAlignment();
 }
 
 bool TransformTree::NeedsSourceToParentUpdate(TransformNode* node) {
   return (source_to_parent_updates_allowed() &&
           node->parent_id != node->source_node_id);
 }
 
 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;
   }
 }
 
 void TransformTree::UpdateTransforms(int id) {
   TransformNode* node = Node(id);
   TransformNode* parent_node = parent(node);
   TransformNode* target_node = Node(TargetId(id));
   TransformNode* source_node = Node(node->source_node_id);
@@ skipping 211 matching lines @@
   float layer_scale_factor =
       device_scale_factor_ * device_transform_scale_factor_;
   if (node->in_subtree_of_page_scale_layer)
     layer_scale_factor *= page_scale_factor_;
   node->sublayer_scale = MathUtil::ComputeTransform2dScaleComponents(
       ToScreen(node->id), layer_scale_factor);
 }
 
 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();
     target_space_transform.Scale(node->sublayer_scale.x(),
                                  node->sublayer_scale.y());
   } else {
     // In order to include the root transform for the root surface, we walk up
     // to the root of the transform tree in ComputeTransform.
     int target_id = target_node->id;
     ComputeTransformWithDestinationSublayerScale(node->id, target_id,
@@ skipping 87 matching lines @@
   // become uninvertible due to floating-point arithmetic.
   if (!node->ancestors_are_invertible && parent_node->ancestors_are_invertible)
     is_invertible = false;
   node->node_and_ancestors_are_animated_or_invertible =
       node->has_potential_animation || is_invertible;
 }
 
 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());
   if (node->post_local == root_post_local)
     return;
 
   node->post_local = root_post_local;
   node->needs_local_transform_update = true;
   set_needs_update(true);
 }
@@ skipping 84 matching lines @@
   DCHECK(static_cast<int>(cached_data_.size()) > node_id);
   cached_data_[node_id].to_screen = transform;
 }
 
 int TransformTree::TargetId(int node_id) const {
   DCHECK(static_cast<int>(cached_data_.size()) > node_id);
   return cached_data_[node_id].target_id;
 }
 
 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;
 }
 
 int TransformTree::ContentTargetId(int node_id) const {
   DCHECK(static_cast<int>(cached_data_.size()) > node_id);
   return cached_data_[node_id].content_target_id;
 }
 
 void TransformTree::SetContentTargetId(int node_id, int content_target_id) {
   DCHECK(static_cast<int>(cached_data_.size()) > node_id);
   cached_data_[node_id].content_target_id = 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);
   gfx::Transform screen_space_transform = ToScreen(id);
   if (node->sublayer_scale.x() != 0.0 && node->sublayer_scale.y() != 0.0)
     screen_space_transform.Scale(1.0 / node->sublayer_scale.x(),
                                  1.0 / node->sublayer_scale.y());
   return screen_space_transform;
 }
 
@@ skipping 32 matching lines @@
 
   for (int i = 0; i < static_cast<int>(cached_data_.size()); ++i)
     cached_data_[i].ToProtobuf(data->add_cached_data());
 }
 
 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);
+  // 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();
 
   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) {
     nodes_affected_by_inner_viewport_bounds_delta_.push_back(
         data.nodes_affected_by_inner_viewport_bounds_delta(i));
   }
 
   DCHECK(nodes_affected_by_outer_viewport_bounds_delta_.empty());
   for (int i = 0; i < data.nodes_affected_by_outer_viewport_bounds_delta_size();
        ++i) {
     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));
   }
 }
 
 EffectTree::EffectTree() {}
 
 EffectTree::~EffectTree() {}
 
 void EffectTree::clear() {
@@ skipping 151 matching lines @@
   copy_requests_.erase(range.first, range.second);
 
   for (auto& it : *requests) {
     if (!it->has_area())
       continue;
 
     // The area needs to be transformed from the space of content that draws to
     // 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 {
       // The root surface doesn't have the notion of sub-layer scale, but
       // instead has a similar notion of transforming from the space of the root
       // layer to the space of the screen.
       DCHECK_EQ(0, destination_id);
       source_id = 1;
     }
     gfx::Transform transform;
@@ skipping 14 matching lines @@
     node.has_copy_request = false;
   }
 
   // Any copy requests that are still left will be aborted (sending an empty
   // result) on destruction.
   copy_requests_.clear();
   set_needs_update(true);
 }
 
 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) {
   mask_replica_layer_ids_.push_back(id);
 }
 
 bool EffectTree::ContributesToDrawnSurface(int id) {
   // All drawn nodes contribute to drawn surface.
   // Exception : Nodes that are hidden and are drawn only for the sake of
   // copy requests.
   EffectNode* node = Node(id);
   EffectNode* parent_node = parent(node);
   return node->is_drawn && (!parent_node || parent_node->is_drawn);
 }
 
 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;
   }
 }
 
 void TransformTree::UpdateNodeAndAncestorsHaveIntegerTranslations(
     TransformNode* node,
     TransformNode* parent_node) {
   node->node_and_ancestors_have_only_integer_translation =
       node->to_parent.IsIdentityOrIntegerTranslation();
   if (parent_node)
     node->node_and_ancestors_have_only_integer_translation =
         node->node_and_ancestors_have_only_integer_translation &&
         parent_node->node_and_ancestors_have_only_integer_translation;
 }
 
 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;
   set_needs_update(true);
 }
 
 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 {
   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,
     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);
 }
 
 EffectTree& EffectTree::operator=(const EffectTree& from) {
   PropertyTree::operator=(from);
   mask_replica_layer_ids_ = from.mask_replica_layer_ids_;
   // copy_requests_ are omitted here, since these need to be moved rather
   // than copied or assigned.
   return *this;
@@ skipping 13 matching lines @@
 
   for (auto i : mask_replica_layer_ids_)
     data->add_mask_replica_layer_ids(i);
 }
 
 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);
+  // 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();
 
   DCHECK(mask_replica_layer_ids_.empty());
   for (int i = 0; i < data.mask_replica_layer_ids_size(); ++i) {
     mask_replica_layer_ids_.push_back(data.mask_replica_layer_ids(i));
   }
 }
 
@@ skipping 55 matching lines @@
     entry->set_layer_id(i.first);
     SyncedScrollOffsetToProto(*i.second.get(), entry->mutable_scroll_offset());
   }
 }
 
 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);
+  // 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();
 
   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) {
@@ skipping 339 matching lines @@
       non_root_surfaces_enabled(true),
       changed(false),
       full_tree_damaged(false),
       sequence_number(0),
       is_main_thread(true),
       is_active(false) {
   transform_tree.SetPropertyTrees(this);
   effect_tree.SetPropertyTrees(this);
   clip_tree.SetPropertyTrees(this);
   scroll_tree.SetPropertyTrees(this);
+  transform_id_to_index_map[Layer::INVALID_ID] = TransformTree::kDeviceNodeId;
 }
 
 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 &&
@@ skipping 147 matching lines @@
       id_to_index_map = &clip_id_to_index_map;
       break;
     case SCROLL:
       id_to_index_map = &scroll_id_to_index_map;
       break;
   }
   return id_to_index_map->find(id) != id_to_index_map->end();
 }
 
 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);
     transform_tree.UpdateTransformChanged(node, parent_node, source_node);
   }
 }
 
 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);
       target_node->transform_changed = true;
     }
   }
   // Ensure that change tracking is updated even if property trees don't have
   // other reasons to get updated.
   tree->UpdateChangeTracking();
   tree->full_tree_damaged = full_tree_damaged;
@@ skipping 188 matching lines @@
   cached_data_.property_tree_update_number = 0;
   cached_data_.animation_scales = std::vector<AnimationScaleData>(
       transform_tree.nodes().size(), AnimationScaleData());
 }
 
 void PropertyTrees::UpdateCachedNumber() {
   cached_data_.property_tree_update_number++;
 }
 
 }  // namespace cc