cc : Remove transform nodes for scroll child

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>
@@ skipping 17 matching lines @@
 
 namespace cc {
 
 namespace {
 
 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;
   int closest_ancestor_with_copy_request;
   const LayerType* page_scale_layer;
   const LayerType* inner_viewport_scroll_layer;
   const LayerType* outer_viewport_scroll_layer;
   const LayerType* overscroll_elasticity_layer;
   gfx::Vector2dF elastic_overscroll;
   float page_scale_factor;
@@ skipping 300 matching lines @@
   // in the Finished state at tree-building time on the main thread is still in
   // the Running state right after commit on the compositor thread.
   const bool has_any_transform_animation =
       HasAnyAnimationTargetingProperty(layer, TargetProperty::TRANSFORM);
 
   const bool has_proxied_transform_related_property =
       !!(layer->mutable_properties() & MutableProperty::kTransformRelated);
 
   const bool has_surface = created_render_surface;
 
-  // A transform node is needed to change the render target for subtree when
-  // a scroll child's render target is different from the scroll parent's render
-  // target.
-  const bool scroll_child_has_different_target =
-      ScrollParent(layer) &&
-      Parent(layer)->effect_tree_index() !=
-          ScrollParent(layer)->effect_tree_index();
-
   const bool is_at_boundary_of_3d_rendering_context =
       IsAtBoundaryOf3dRenderingContext(layer);
 
   DCHECK(!is_scrollable || is_snapped);
   bool requires_node = is_root || is_snapped || has_significant_transform ||
                        has_any_transform_animation || has_surface || is_fixed ||
                        is_page_scale_layer || is_overscroll_elasticity_layer ||
-                       has_proxied_transform_related_property ||
-                       scroll_child_has_different_target || is_sticky ||
+                       has_proxied_transform_related_property || is_sticky ||
                        is_at_boundary_of_3d_rendering_context;
 
   int parent_index = TransformTree::kRootNodeId;
   int source_index = TransformTree::kRootNodeId;
   gfx::Vector2dF source_offset;
 
   LayerType* transform_parent = GetTransformParent(data_from_ancestor, layer);
   DCHECK_EQ(is_root, !transform_parent);
 
   if (transform_parent) {
@@ skipping 755 matching lines @@
     LayerType* layer,
     const DataForRecursion<LayerType>& data_from_parent) {
   layer->set_property_tree_sequence_number(
       data_from_parent.property_trees->sequence_number);
 
   DataForRecursion<LayerType> data_for_children(data_from_parent);
 
   bool created_render_surface =
       AddEffectNodeIfNeeded(data_from_parent, layer, &data_for_children);
 
-  if (created_render_surface)
-    data_for_children.render_target = data_for_children.effect_tree_parent;
 
   bool created_transform_node = AddTransformNodeIfNeeded(
       data_from_parent, layer, created_render_surface, &data_for_children);
   AddClipNodeIfNeeded(data_from_parent, layer, created_transform_node,
                       &data_for_children);
 
   AddScrollNodeIfNeeded(data_from_parent, layer, &data_for_children);
 
   SetBackfaceVisibilityTransform(layer, created_transform_node);
   SetSafeOpaqueBackgroundColor(data_from_parent, layer, &data_for_children);
 
   for (size_t i = 0; i < Children(layer).size(); ++i) {
     LayerType* current_child = ChildAt(layer, i);
     SetLayerPropertyChangedForChild(layer, current_child);
     if (!ScrollParent(current_child)) {
       BuildPropertyTreesInternal(current_child, data_for_children);
     } else {
       // The child should be included in its scroll parent's list of scroll
       // children.
       DCHECK(ScrollChildren(ScrollParent(current_child))->count(current_child));
     }
   }
 
   if (ScrollChildren(layer)) {
     for (LayerType* scroll_child : *ScrollChildren(layer)) {
       DCHECK_EQ(ScrollParent(scroll_child), layer);
       DCHECK(Parent(scroll_child));
       data_for_children.effect_tree_parent =
           Parent(scroll_child)->effect_tree_index();
-      data_for_children.render_target =
-          Parent(scroll_child)->effect_tree_index();
       BuildPropertyTreesInternal(scroll_child, data_for_children);
     }
   }
 
   if (MaskLayer(layer)) {
     MaskLayer(layer)->set_property_tree_sequence_number(
         data_from_parent.property_trees->sequence_number);
     MaskLayer(layer)->set_offset_to_transform_parent(
         layer->offset_to_transform_parent());
     MaskLayer(layer)->SetTransformTreeIndex(layer->transform_tree_index());
@@ skipping 47 matching lines @@
     property_trees->transform_tree.SetRootTransformsAndScales(
         device_scale_factor, page_scale_factor_for_root, device_transform,
         root_layer->position());
     return;
   }
 
   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 = EffectTree::kRootNodeId;
   data_for_recursion.clip_tree_parent = ClipTree::kRootNodeId;
   data_for_recursion.effect_tree_parent = EffectTree::kInvalidNodeId;
   data_for_recursion.scroll_tree_parent = ScrollTree::kRootNodeId;
   data_for_recursion.closest_ancestor_with_copy_request =
       EffectTree::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;
@@ skipping 118 matching lines @@
       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);
   property_trees->effect_tree.CreateOrReuseRenderSurfaces(
       &render_surfaces, root_layer->layer_tree_impl());
   property_trees->ResetCachedData();
 }
 
 }  // namespace cc