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 48 matching lines @@
 }
 
 template struct TreeNode<TransformNodeData>;
 template struct TreeNode<ClipNodeData>;
 template struct TreeNode<EffectNodeData>;
 template struct TreeNode<ScrollNodeData>;
 
 template <typename T>
 PropertyTree<T>::PropertyTree()
     : needs_update_(false) {
-  nodes_.push_back(T());
-  back()->id = 0;
-  back()->parent_id = -1;
 }
 
 template <typename T>
 PropertyTree<T>::~PropertyTree() {
 }
 
 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(TreeNode<TransformNodeData>(), kInvalidNodeId);
 }
 
 TransformTree::~TransformTree() {
 }
 
 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.

[ajuma, 2016/06/22 13:29:51]

I think this comment is obsolete now.

+  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 {
@@ skipping 243 matching lines @@
   MathUtil::AddToTracedValue("local", local, value);
   MathUtil::AddToTracedValue("post_local", post_local, value);
   // TODO(sunxd): make frameviewer work without target_id
   value->SetInteger("target_id", 0);
   value->SetInteger("content_target_id", 0);
   value->SetInteger("source_node_id", source_node_id);
   value->SetInteger("sorting_context_id", sorting_context_id);
 }
 
 TransformCachedNodeData::TransformCachedNodeData()
-    : target_id(-1), content_target_id(-1) {}
+    : target_id(TransformTree::kDeviceNodeId),
+      content_target_id(TransformTree::kDeviceNodeId) {}
 
 TransformCachedNodeData::TransformCachedNodeData(
     const TransformCachedNodeData& other) = default;
 
 TransformCachedNodeData::~TransformCachedNodeData() {}
 
 bool TransformCachedNodeData::operator==(
     const TransformCachedNodeData& other) const {
   return from_target == other.from_target && to_target == other.to_target &&
          from_screen == other.from_screen && to_screen == other.to_screen &&
          target_id == other.target_id &&
          content_target_id == other.content_target_id;
 }
 
 void TransformCachedNodeData::ToProtobuf(
     proto::TransformCachedNodeData* proto) const {
   TransformToProto(from_target, proto->mutable_from_target());
   TransformToProto(to_target, proto->mutable_to_target());
   TransformToProto(from_screen, proto->mutable_from_screen());
   TransformToProto(to_screen, proto->mutable_to_screen());
+  DCHECK(target_id >= 0) << target_id;
   proto->set_target_id(target_id);
   proto->set_content_target_id(content_target_id);
 }
 
 void TransformCachedNodeData::FromProtobuf(
     const proto::TransformCachedNodeData& proto) {
   from_target = ProtoToTransform(proto.from_target());
   to_target = ProtoToTransform(proto.to_target());
   from_screen = ProtoToTransform(proto.from_screen());
   to_screen = ProtoToTransform(proto.to_screen());
@@ skipping 291 matching lines @@
                              offset_to_transform_parent, value);
   value->SetBoolean("should_flatten", should_flatten);
   value->SetBoolean("user_scrollable_horizontal", user_scrollable_horizontal);
   value->SetBoolean("user_scrollable_vertical", user_scrollable_vertical);
   value->SetInteger("element_id", element_id);
   value->SetInteger("transform_id", transform_id);
 }
 
 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->data.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->data.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->data.source_node_id);
@@ skipping 216 matching lines @@
   float layer_scale_factor =
       device_scale_factor_ * device_transform_scale_factor_;
   if (node->data.in_subtree_of_page_scale_layer)
     layer_scale_factor *= page_scale_factor_;
   node->data.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->data.needs_sublayer_scale) {
     target_space_transform.MakeIdentity();
     target_space_transform.Scale(node->data.sublayer_scale.x(),
                                  node->data.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 175 matching lines @@
   if (!node->data.ancestors_are_invertible &&
       parent_node->data.ancestors_are_invertible)
     is_invertible = false;
   node->data.node_and_ancestors_are_animated_or_invertible =
       node->data.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->data.post_local_scale_factor,
                         node->data.post_local_scale_factor);
   root_post_local.Translate(root_position.x(), root_position.y());
   if (node->data.post_local == root_post_local)
     return;
 
   node->data.post_local = root_post_local;
   node->data.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. "

[ajuma, 2016/06/22 13:29:51]

These can be DCHECK_GE (and then we get a readable error for free).

+                                               << size();
+  DCHECK_GE(target_id, TransformTree::kDeviceNodeId) << target_id;
+  DCHECK_LE(target_id, node_id) << target_id << " v.s. " << node_id;

[ajuma, 2016/06/22 13:29:50]

No need to include the error message here since DCHECK_{GE,LE} will take care of
that.

   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->data.sublayer_scale.x() != 0.0 &&
       node->data.sublayer_scale.y() != 0.0)
     screen_space_transform.Scale(1.0 / node->data.sublayer_scale.x(),
                                  1.0 / node->data.sublayer_scale.y());
   return screen_space_transform;
 }
@@ skipping 33 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));

[ajuma, 2016/06/22 13:29:51]

<_<

+  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 134 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->data.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);

[ajuma, 2016/06/22 17:06:57]

TransformTree::kDeviceNodeId

       source_id = 1;

[ajuma, 2016/06/22 17:06:57]

TransformTree::kRootNodeId

     }
     gfx::Transform transform;
     property_trees()
         ->transform_tree.ComputeTransformWithDestinationSublayerScale(
             source_id, destination_id, &transform);
     it->set_area(MathUtil::MapEnclosingClippedRect(transform, it->area()));
   }
 }
 
 bool EffectTree::HasCopyRequests() const {
@@ skipping 19 matching lines @@
 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->data.is_drawn && (!parent_node || parent_node->data.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->data.effect_changed = false;
   }
 }
 
 void TransformTree::UpdateNodeAndAncestorsHaveIntegerTranslations(
     TransformNode* node,
     TransformNode* parent_node) {
   node->data.node_and_ancestors_have_only_integer_translation =
       node->data.to_parent.IsIdentityOrIntegerTranslation();
   if (parent_node)
     node->data.node_and_ancestors_have_only_integer_translation =
         node->data.node_and_ancestors_have_only_integer_translation &&
         parent_node->data.node_and_ancestors_have_only_integer_translation;
 }
 
 void ClipTree::SetViewportClip(gfx::RectF viewport_rect) {
   if (size() < 2)

[ajuma, 2016/06/22 17:06:57]

I think this should be 1 now that the viewport has shifted to node 0.

     return;
-  ClipNode* node = Node(1);
+  ClipNode* node = Node(ClipTree::kViewportNodeId);
   if (viewport_rect == node->data.clip)
     return;
   node->data.clip = viewport_rect;
   set_needs_update(true);
 }
 
 gfx::RectF ClipTree::ViewportClip() {
   const unsigned long min_size = 1;
   DCHECK_GT(size(), min_size);

[ajuma, 2016/06/22 17:06:57]

And this should be a DCHECK_GE now.

-  return Node(1)->data.clip;
+  return Node(ClipTree::kViewportNodeId)->data.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 333 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 146 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->data.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->data.effect_changed) {
       EffectNode* target_node = tree->effect_tree.Node(node->id);
       target_node->data.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->data.transform_changed) {
       TransformNode* target_node = tree->transform_tree.Node(node->id);
       target_node->data.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 25 matching lines @@
   value->EndDictionary();
 
   value->BeginDictionary("scroll_tree");
   scroll_tree.AsValueInto(value.get());
   value->EndDictionary();
 
   return value;
 }
 
 }  // namespace cc