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

cc/trees/property_tree_builder.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/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 
 class LayerTreeHost;
 
 namespace {
 
-static const int kInvalidPropertyTreeNodeId = -1;
-static const int kRootPropertyTreeNodeId = 0;
-static const int kViewportClipTreeNodeId = 1;
-
 template <typename LayerType>
 struct DataForRecursion {
   PropertyTrees* property_trees;
   LayerType* transform_tree_parent;
   LayerType* transform_fixed_parent;
   int render_target;
   int clip_tree_parent;
   int effect_tree_parent;
   int scroll_tree_parent;
   const LayerType* page_scale_layer;
@@ skipping 402 matching lines @@
 
   bool requires_node = is_root || is_scrollable || has_significant_transform ||
                        has_any_transform_animation || has_surface || is_fixed ||
                        is_page_scale_layer || is_overscroll_elasticity_layer ||
                        scroll_child_has_different_target ||
                        is_at_boundary_of_3d_rendering_context;
 
   LayerType* transform_parent = GetTransformParent(data_from_ancestor, layer);
   DCHECK(is_root || transform_parent);
 
-  int parent_index = kRootPropertyTreeNodeId;
+  int parent_index = TransformTree::kDeviceNodeId;
   if (transform_parent)
     parent_index = transform_parent->transform_tree_index();
 
   int source_index = parent_index;
 
   gfx::Vector2dF source_offset;
   if (transform_parent) {
     if (ScrollParent(layer)) {
       LayerType* source = layer->parent();
       source_offset += source->offset_to_transform_parent();
@@ skipping 63 matching lines @@
   if (layer == data_from_ancestor.page_scale_layer)
     data_for_children->in_subtree_of_page_scale_layer = true;
   node->data.in_subtree_of_page_scale_layer =
       data_for_children->in_subtree_of_page_scale_layer;
 
   // Surfaces inherently flatten transforms.
   data_for_children->should_flatten =
       ShouldFlattenTransform(layer) || has_surface;
   DCHECK_GT(data_from_ancestor.property_trees->effect_tree.size(), 0u);
 
-  data_for_children->property_trees->transform_tree.SetTargetId(
-      node->id, data_for_children->property_trees->effect_tree
-                    .Node(data_from_ancestor.render_target)
-                    ->data.transform_id);
+  if (data_from_ancestor.render_target == EffectTree::kInvalidNodeId) {
+    data_for_children->property_trees->transform_tree.SetTargetId(
+        node->id, TransformTree::kDeviceNodeId);
+  } else {
+    data_for_children->property_trees->transform_tree.SetTargetId(
+        node->id, data_for_children->property_trees->effect_tree
+                      .Node(data_from_ancestor.render_target)
+                      ->data.transform_id);
+  }
   data_for_children->property_trees->transform_tree.SetContentTargetId(
       node->id, data_for_children->property_trees->effect_tree
                     .Node(data_for_children->render_target)
                     ->data.transform_id);
   DCHECK_NE(
       data_for_children->property_trees->transform_tree.TargetId(node->id),
-      kInvalidPropertyTreeNodeId);
+      TransformTree::kInvalidNodeId);
 
   node->data.has_potential_animation = has_potentially_animated_transform;
   node->data.is_currently_animating = layer->TransformIsAnimating();
   if (has_potentially_animated_transform) {
     float maximum_animation_target_scale = 0.f;
     if (layer->MaximumTargetScale(&maximum_animation_target_scale)) {
       node->data.local_maximum_animation_target_scale =
           maximum_animation_target_scale;
     }
 
@@ skipping 365 matching lines @@
           data_from_ancestor.property_trees->transform_tree.next_available_id();
       node.data.has_unclipped_descendants =
           (NumUnclippedDescendants(layer) != 0);
     }
     node.data.clip_id = data_from_ancestor.clip_tree_parent;
   } else {
     // Root render surface acts the unbounded and untransformed to draw content
     // into. Transform node created from root layer (includes device scale
     // factor) and clip node created from root layer (include viewports) applies
     // to root render surface's content, but not root render surface itself.
-    node.data.transform_id = kRootPropertyTreeNodeId;
-    node.data.clip_id = kViewportClipTreeNodeId;
+    node.data.transform_id = TransformTree::kDeviceNodeId;
+    node.data.clip_id = ClipTree::kRootNodeId;
   }
   data_for_children->effect_tree_parent = effect_tree.Insert(node, parent_id);
   int node_id = data_for_children->effect_tree_parent;
   layer->SetEffectTreeIndex(node_id);
   data_for_children->property_trees->effect_id_to_index_map[layer->id()] =
       data_for_children->effect_tree_parent;
 
   std::vector<std::unique_ptr<CopyOutputRequest>> layer_copy_requests;
   TakeCopyRequests(layer, &layer_copy_requests);
   for (auto& it : layer_copy_requests) {
@@ skipping 42 matching lines @@
     ScrollNode node;
     node.owner_id = layer->id();
     node.data.scrollable = scrollable;
     node.data.main_thread_scrolling_reasons = main_thread_scrolling_reasons;
     node.data.contains_non_fast_scrollable_region =
         contains_non_fast_scrollable_region;
     gfx::Size clip_bounds;
     if (layer->scroll_clip_layer()) {
       clip_bounds = layer->scroll_clip_layer()->bounds();
       DCHECK(layer->scroll_clip_layer()->transform_tree_index() !=
-             kInvalidPropertyTreeNodeId);
+             TransformTree::kInvalidNodeId);
       node.data.max_scroll_offset_affected_by_page_scale =
           !data_from_ancestor.property_trees->transform_tree
                .Node(layer->scroll_clip_layer()->transform_tree_index())
                ->data.in_subtree_of_page_scale_layer &&
           data_from_ancestor.in_subtree_of_page_scale_layer;
     }
 
     node.data.scroll_clip_layer_bounds = clip_bounds;
     node.data.is_inner_viewport_scroll_layer =
         layer == data_from_ancestor.inner_viewport_scroll_layer;
@@ skipping 231 matching lines @@
                                                       root_layer->position());
     return;
   }
 
   property_trees->sequence_number++;
 
   DataForRecursion<LayerType> data_for_recursion;
   data_for_recursion.property_trees = property_trees;
   data_for_recursion.transform_tree_parent = nullptr;
   data_for_recursion.transform_fixed_parent = nullptr;
-  data_for_recursion.render_target = kRootPropertyTreeNodeId;
-  data_for_recursion.clip_tree_parent = kRootPropertyTreeNodeId;
-  data_for_recursion.effect_tree_parent = kInvalidPropertyTreeNodeId;
-  data_for_recursion.scroll_tree_parent = kRootPropertyTreeNodeId;
+  data_for_recursion.render_target = EffectTree::kInvalidNodeId;
+  data_for_recursion.clip_tree_parent = ClipTree::kInvalidNodeId;
+  data_for_recursion.effect_tree_parent = EffectTree::kInvalidNodeId;
+  data_for_recursion.scroll_tree_parent = ScrollTree::kInvalidNodeId;
   data_for_recursion.page_scale_layer = page_scale_layer;
   data_for_recursion.inner_viewport_scroll_layer = inner_viewport_scroll_layer;
   data_for_recursion.outer_viewport_scroll_layer = outer_viewport_scroll_layer;
   data_for_recursion.overscroll_elasticity_layer = overscroll_elasticity_layer;
   data_for_recursion.elastic_overscroll = elastic_overscroll;
   data_for_recursion.page_scale_factor = page_scale_factor;
   data_for_recursion.in_subtree_of_page_scale_layer = false;
   data_for_recursion.affected_by_inner_viewport_bounds_delta = false;
   data_for_recursion.affected_by_outer_viewport_bounds_delta = false;
   data_for_recursion.should_flatten = false;
@@ skipping 18 matching lines @@
   data_for_recursion.property_trees->effect_id_to_index_map.clear();
   data_for_recursion.property_trees->clip_id_to_index_map.clear();
   data_for_recursion.property_trees->scroll_id_to_index_map.clear();
   data_for_recursion.property_trees->always_use_active_tree_opacity_effect_ids
       .clear();
 
   ClipNode root_clip;
   root_clip.data.resets_clip = true;
   root_clip.data.applies_local_clip = true;
   root_clip.data.clip = gfx::RectF(viewport);
-  root_clip.data.transform_id = kRootPropertyTreeNodeId;
+  root_clip.data.transform_id = TransformTree::kDeviceNodeId;
   data_for_recursion.clip_tree_parent =
       data_for_recursion.property_trees->clip_tree.Insert(
-          root_clip, kRootPropertyTreeNodeId);
+          root_clip, ClipTree::kInvalidNodeId);
 
   DataForRecursionFromChild<LayerType> data_from_child;
   BuildPropertyTreesInternal(root_layer, data_for_recursion, &data_from_child);
   property_trees->needs_rebuild = false;
 
   // The transform tree is kept up-to-date as it is built, but the
   // combined_clips stored in the clip tree and the screen_space_opacity and
   // is_drawn in the effect tree aren't computed during tree building.
   property_trees->transform_tree.set_needs_update(false);
   property_trees->clip_tree.set_needs_update(true);
@@ skipping 68 matching lines @@
   if (SkColorGetA(color) != 255)
     color = SkColorSetA(color, 255);
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees, color);
 }
 
 }  // namespace cc