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 490 matching lines @@
   if (std::isnan(rect->x()) || std::isnan(rect->y()) ||
       std::isnan(rect->right()) || std::isnan(rect->bottom()))
     *rect = gfx::RectF();
 }
 
 void ComputeClips(ClipTree* clip_tree,
                   const TransformTree& transform_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->data.clip);
       clip_node->data.clip_in_target_space = clip_node->data.clip;
       clip_node->data.combined_clip_in_target_space = clip_node->data.clip;
       continue;
     }
     const TransformNode* transform_node =
         transform_tree.Node(clip_node->data.transform_id);
     ClipNode* parent_clip_node = clip_tree->parent(clip_node);
 
     gfx::Transform parent_to_current;
@@ skipping 116 matching lines @@
     }
     ResetIfHasNanCoordinate(&clip_node->data.clip_in_target_space);
     ResetIfHasNanCoordinate(&clip_node->data.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->data.target_id = 0;
+      node->data.target_id = EffectTree::kRootNodeId;
     } else if (!can_render_to_separate_surface) {

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

This can be combined with the previous condition now that both branches use
kRootNodeId.

-      node->data.target_id = 1;
+      node->data.target_id = EffectTree::kRootNodeId;
     } else if (effect_tree->parent(node)->data.has_render_surface) {
       node->data.target_id = node->parent_id;
     } else {
       node->data.target_id = effect_tree->parent(node)->data.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 gfx::RectF ComputeCurrentClip(const ClipNode* clip_node,
                                      const TransformTree& transform_tree,
                                      int target_transform_id) {
   if (clip_node->data.transform_id != target_transform_id) {
     gfx::Transform current_to_target;
     if (!transform_tree.ComputeTransformWithDestinationSublayerScale(
@@ skipping 76 matching lines @@
     accumulated_clip = gfx::IntersectRects(accumulated_clip, current_clip);
   }
 
   return accumulated_clip.IsEmpty() ? gfx::RectF() : accumulated_clip;
 }
 
 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->data.render_surface;
   gfx::Rect root_clip = gfx::ToEnclosingRect(
       clip_tree->Node(root_effect_node->data.clip_id)->data.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) {

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

Should this be kRootNodeId+1 instead of 2?

     EffectNode* effect_node = effect_tree->Node(i);
     const EffectNode* target_node =
         effect_tree->Node(effect_node->data.target_id);
     gfx::RectF accumulated_clip =
         ComputeAccumulatedClip(*clip_tree, effect_node->data.clip_id,
                                *effect_tree, target_node->id, *transform_tree);
     const RenderSurfaceImpl* render_surface = effect_node->data.render_surface;
     if (render_surface && render_surface->is_clipped()) {
       DCHECK(gfx::ToEnclosingRect(accumulated_clip) ==
              render_surface->clip_rect())
@@ skipping 11 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->data.has_render_surface
           ? effect_node
           : effect_tree->Node(effect_node->data.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);
   }
 
   gfx::RectF accumulated_clip =
       ComputeAccumulatedClip(*clip_tree, layer->clip_tree_index(), *effect_tree,
                              target_node->id, *transform_tree);
 
   if ((!property_trees->non_root_surfaces_enabled &&
        clip_tree->Node(layer->clip_tree_index())
            ->data.layers_are_clipped_when_surfaces_disabled) ||
       clip_tree->Node(layer->clip_tree_index())->data.layers_are_clipped) {
@@ skipping 151 matching lines @@
     // Surfaces need to apply their sublayer scale.
     xform.Scale(node->data.sublayer_scale.x(), node->data.sublayer_scale.y());
   }
   return xform;
 }
 
 static void SetSurfaceDrawTransform(const TransformTree& tree,
                                     RenderSurfaceImpl* render_surface) {
   const TransformNode* node = tree.Node(render_surface->TransformTreeIndex());
   // The draw transform of root render surface is identity tranform.
-  if (node->id == 1) {
+  if (node->id == TransformTree::kRootNodeId) {
     render_surface->SetDrawTransform(gfx::Transform());
     return;
   }
 
   gfx::Transform render_surface_transform;
   const TransformNode* target_node = tree.Node(tree.TargetId(node->id));
   tree.ComputeTransformWithDestinationSublayerScale(node->id, target_node->id,
                                                     &render_surface_transform);
   if (node->data.sublayer_scale.x() != 0.0 &&
       node->data.sublayer_scale.y() != 0.0)
@@ skipping 320 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