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

cc/trees/draw_property_utils.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/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 355 matching lines @@
     const typename LayerType::LayerListType& visible_layer_list,
     const ClipTree& clip_tree,
     const TransformTree& transform_tree,
     const EffectTree& effect_tree,
     bool non_root_surfaces_enabled) {
   for (auto& layer : visible_layer_list) {
     gfx::Size layer_bounds = layer->bounds();
 
     int effect_ancestor_with_copy_request =
         effect_tree.ClosestAncestorWithCopyRequest(layer->effect_tree_index());
-    if (effect_ancestor_with_copy_request > 1) {
+    if (effect_ancestor_with_copy_request > EffectTree::kRootNodeId) {
       // Non root copy request.
       ConditionalClip accumulated_clip_rect = ComputeAccumulatedClip(
           clip_tree, layer->clip_tree_index(), effect_tree,
           effect_ancestor_with_copy_request, transform_tree);
       if (!accumulated_clip_rect.is_clipped) {
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
 
       gfx::RectF accumulated_clip_in_copy_request_space =
@@ skipping 327 matching lines @@
       std::isnan(rect->right()) || std::isnan(rect->bottom()))
     *rect = gfx::RectF();
 }
 
 void ComputeClips(ClipTree* clip_tree,
                   const TransformTree& transform_tree,
                   const EffectTree& effect_tree,
                   bool non_root_surfaces_enabled) {
   if (!clip_tree->needs_update())
     return;
-  for (int i = 1; i < static_cast<int>(clip_tree->size()); ++i) {
+  for (int i = ClipTree::kRootNodeId; i < static_cast<int>(clip_tree->size());
+       ++i) {
     ClipNode* clip_node = clip_tree->Node(i);
 
-    if (clip_node->id == 1) {
+    if (clip_node->id == ClipTree::kRootNodeId) {
       ResetIfHasNanCoordinate(&clip_node->clip);
       clip_node->clip_in_target_space = clip_node->clip;
       clip_node->combined_clip_in_target_space = clip_node->clip;
       continue;
     }
     const TransformNode* transform_node =
         transform_tree.Node(clip_node->transform_id);
     ClipNode* parent_clip_node = clip_tree->parent(clip_node);
 
     gfx::Transform parent_to_current;
@@ skipping 132 matching lines @@
     }
     ResetIfHasNanCoordinate(&clip_node->clip_in_target_space);
     ResetIfHasNanCoordinate(&clip_node->combined_clip_in_target_space);
   }
   clip_tree->set_needs_update(false);
 }
 
 void ComputeTransforms(TransformTree* transform_tree) {
   if (!transform_tree->needs_update())
     return;
-  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)
     transform_tree->UpdateTransforms(i);
   transform_tree->set_needs_update(false);
 }
 
 void UpdateRenderTarget(EffectTree* effect_tree,
                         bool can_render_to_separate_surface) {
-  for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i) {
+  for (int i = EffectTree::kRootNodeId;
+       i < static_cast<int>(effect_tree->size()); ++i) {
     EffectNode* node = effect_tree->Node(i);
-    if (i == 1) {
+    if (i == EffectTree::kRootNodeId) {
       // Render target on the first effect node is root.
-      node->target_id = 0;
+      node->target_id = EffectTree::kRootNodeId;
     } else if (!can_render_to_separate_surface) {
-      node->target_id = 1;
+      node->target_id = EffectTree::kRootNodeId;
     } else if (effect_tree->parent(node)->has_render_surface) {
       node->target_id = node->parent_id;
     } else {
       node->target_id = effect_tree->parent(node)->target_id;
     }
   }
 }
 
 void ComputeEffects(EffectTree* effect_tree) {
   if (!effect_tree->needs_update())
     return;
-  for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i)
+  for (int i = EffectTree::kRootNodeId;
+       i < static_cast<int>(effect_tree->size()); ++i)
     effect_tree->UpdateEffects(i);
   effect_tree->set_needs_update(false);
 }
 
 static void ComputeClipsWithEffectTree(PropertyTrees* property_trees) {
   EffectTree* effect_tree = &property_trees->effect_tree;
   const ClipTree* clip_tree = &property_trees->clip_tree;
   const TransformTree* transform_tree = &property_trees->transform_tree;
-  EffectNode* root_effect_node = effect_tree->Node(1);
+  EffectNode* root_effect_node = effect_tree->Node(EffectTree::kRootNodeId);
   const RenderSurfaceImpl* root_render_surface =
       root_effect_node->render_surface;
   gfx::Rect root_clip =
       gfx::ToEnclosingRect(clip_tree->Node(root_effect_node->clip_id)->clip);
   if (root_render_surface->is_clipped())
     DCHECK(root_clip == root_render_surface->clip_rect())
         << "clip on root render surface: "
         << root_render_surface->clip_rect().ToString()
         << " v.s. root effect node's clip: " << root_clip.ToString();
   for (int i = 2; i < static_cast<int>(effect_tree->size()); ++i) {
@@ skipping 21 matching lines @@
   const ClipTree* clip_tree = &property_trees->clip_tree;
   const TransformTree* transform_tree = &property_trees->transform_tree;
   const EffectNode* effect_node = effect_tree->Node(layer->effect_tree_index());
   const EffectNode* target_node =
       effect_node->has_render_surface
           ? effect_node
           : effect_tree->Node(effect_node->target_id);
   // TODO(weiliangc): When effect node has up to date render surface info on
   // compositor thread, no need to check for resourceless draw mode
   if (!property_trees->non_root_surfaces_enabled) {
-    target_node = effect_tree->Node(1);
+    target_node = effect_tree->Node(EffectTree::kRootNodeId);
   }
 
   ConditionalClip accumulated_clip_rect =
       ComputeAccumulatedClip(*clip_tree, layer->clip_tree_index(), *effect_tree,
                              target_node->id, *transform_tree);
 
   gfx::RectF accumulated_clip = accumulated_clip_rect.clip_rect;
 
   if ((!property_trees->non_root_surfaces_enabled &&
        clip_tree->Node(layer->clip_tree_index())
@@ skipping 208 matching lines @@
 }
 
 static void SetSurfaceDrawTransform(const TransformTree& transform_tree,
                                     const EffectTree& effect_tree,
                                     RenderSurfaceImpl* render_surface) {
   const TransformNode* transform_node =
       transform_tree.Node(render_surface->TransformTreeIndex());
   const EffectNode* effect_node =
       effect_tree.Node(render_surface->EffectTreeIndex());
   // The draw transform of root render surface is identity tranform.
-  if (transform_node->id == 1) {
+  if (transform_node->id == TransformTree::kRootNodeId) {
     render_surface->SetDrawTransform(gfx::Transform());
     return;
   }
 
   gfx::Transform render_surface_transform;
   const TransformNode* target_transform_node =
       transform_tree.Node(transform_tree.TargetId(transform_node->id));
   transform_tree.ComputeTransform(transform_node->id, target_transform_node->id,
                                   &render_surface_transform);
   // We don't have to apply sublayer scale when target is root.
@@ skipping 331 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc