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

cc/trees/layer_tree_impl.cc

 // Copyright 2011 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/layer_tree_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 127 matching lines @@
   // If pending tree topology changed and we still want to notify the pending
   // tree about scroll offset in the active tree, we may not find the
   // corresponding pending layer.
   if (LayerById(layer_id)) {
     transform_id = LayerById(layer_id)->transform_tree_index();
   } else {
     DCHECK(!IsActiveTree());
     return;
   }
 
-  if (transform_id != -1) {
+  if (transform_id != TransformTree::kInvalidNodeId) {
     TransformNode* node = transform_tree.Node(transform_id);
     if (node->data.scroll_offset !=
         scroll_tree.current_scroll_offset(layer_id)) {
       node->data.scroll_offset = scroll_tree.current_scroll_offset(layer_id);
       node->data.needs_local_transform_update = true;
       transform_tree.set_needs_update(true);
     }
     node->data.transform_changed = true;
     property_trees()->changed = true;
     set_needs_update_draw_properties();
@@ skipping 391 matching lines @@
 
 int LayerTreeImpl::LastScrolledLayerId() const {
   return last_scrolled_layer_id_;
 }
 
 void LayerTreeImpl::SetCurrentlyScrollingLayer(LayerImpl* layer) {
   ScrollTree& scroll_tree = property_trees()->scroll_tree;
   ScrollNode* scroll_node = scroll_tree.CurrentlyScrollingNode();
   int old_id = scroll_node ? scroll_node->owner_id : Layer::INVALID_ID;
   int new_id = layer ? layer->id() : Layer::INVALID_ID;
-  int new_scroll_node_id = layer ? layer->scroll_tree_index() : -1;
+  int new_scroll_node_id =
+      layer ? layer->scroll_tree_index() : ScrollTree::kInvalidNodeId;
   if (layer)
     last_scrolled_layer_id_ = new_id;
 
   if (old_id == new_id)
     return;
 
   ScrollbarAnimationController* old_animation_controller =
       layer_tree_host_impl_->ScrollbarAnimationControllerForId(old_id);
   ScrollbarAnimationController* new_animation_controller =
       layer_tree_host_impl_->ScrollbarAnimationControllerForId(new_id);
@@ skipping 1046 matching lines @@
     const ClipTree& clip_tree,
     const TransformTree& transform_tree) {
   // We need to visit all ancestor clip nodes to check this. Checking with just
   // the combined clip stored at a clip node is not enough because parent
   // combined clip can sometimes be smaller than current combined clip. This can
   // happen when we have transforms like rotation that inflate the combined
   // clip's bounds. Also, the point can be clipped by the content rect of an
   // ancestor render surface.
 
   // We first check if the point is clipped by viewport.
-  const ClipNode* clip_node = clip_tree.Node(1);
+  const ClipNode* clip_node = clip_tree.Node(ClipTree::kViewportNodeId);
   gfx::Rect combined_clip_in_target_space =
       gfx::ToEnclosingRect(clip_node->data.combined_clip_in_target_space);
   if (!PointHitsRect(screen_space_point, gfx::Transform(),
                      combined_clip_in_target_space, NULL))
     return true;
 
   for (const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index());
-       clip_node->id > 1; clip_node = clip_tree.parent(clip_node)) {
+       clip_node->id > ClipTree::kViewportNodeId;
+       clip_node = clip_tree.parent(clip_node)) {
     if (clip_node->data.applies_local_clip) {
       const TransformNode* transform_node =
           transform_tree.Node(clip_node->data.target_id);
       gfx::Rect combined_clip_in_target_space =
           gfx::ToEnclosingRect(clip_node->data.combined_clip_in_target_space);
 
       const LayerImpl* target_layer =
           layer->layer_tree_impl()->LayerById(transform_node->owner_id);
-      DCHECK(transform_node->id == 0 || target_layer->render_surface() ||
+      DCHECK(transform_node->id == TransformTree::kDeviceNodeId ||
+             target_layer->render_surface() ||
              layer->layer_tree_impl()->is_in_resourceless_software_draw_mode());
       gfx::Transform surface_screen_space_transform =
-          transform_node->id == 0 ||
+          transform_node->id == TransformTree::kDeviceNodeId ||
                   (layer->layer_tree_impl()
                        ->is_in_resourceless_software_draw_mode())
               ? gfx::Transform()
               : SurfaceScreenSpaceTransform(target_layer, transform_tree);
       if (!PointHitsRect(screen_space_point, surface_screen_space_transform,
                          combined_clip_in_target_space, NULL)) {
         return true;
       }
     }
     const LayerImpl* clip_node_owner =
@@ skipping 420 matching lines @@
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   // Iterate over all layers, including masks and replicas.
   for (auto& layer : *layers_)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc