cc: Compute target space transform dynamically

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 461 matching lines @@
     } else {
       if (clip_node->target_is_clipped) {
         combined_clip_rect_in_target_space =
             clip_node->combined_clip_in_target_space;
       } else {
         combined_clip_rect_in_target_space = clip_node->clip_in_target_space;
       }
     }
 
     // The clip rect should be intersected with layer rect in target space.
-    gfx::Transform content_to_target =
-        transform_tree.ToTarget(transform_node->id);
+    gfx::Transform content_to_target = transform_tree.ToTarget(
+        transform_node->id, layer->render_target_effect_tree_index());
     content_to_target.Translate(layer->offset_to_transform_parent().x(),
                                 layer->offset_to_transform_parent().y());
     gfx::Rect layer_content_rect = gfx::Rect(layer_bounds);
     gfx::RectF layer_content_bounds_in_target_space = MathUtil::MapClippedRect(
         content_to_target, gfx::RectF(layer_content_rect));
     // If the layer is fully contained within the clip, treat it as fully
     // visible.
     if (!layer_content_bounds_in_target_space.IsEmpty() &&
         combined_clip_rect_in_target_space.Contains(
             layer_content_bounds_in_target_space)) {
       layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
       continue;
     }
 
     combined_clip_rect_in_target_space.Intersect(
         layer_content_bounds_in_target_space);
     if (combined_clip_rect_in_target_space.IsEmpty()) {
       layer->set_visible_layer_rect(gfx::Rect());
       continue;
     }
 
     gfx::Transform target_to_layer;
     if (transform_node->ancestors_are_invertible) {
-      target_to_layer = transform_tree.FromTarget(transform_node->id);
+      target_to_layer = transform_tree.FromTarget(
+          transform_node->id, layer->render_target_effect_tree_index());
     } else {
       bool success = transform_tree.ComputeTransform(
           target_node_id, transform_node->id, &target_to_layer);
       if (!success) {
         // An animated singular transform may become non-singular during the
         // animation, so we still need to compute a visible rect. In this
         // situation, we treat the entire layer as visible.
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
@@ skipping 34 matching lines @@
   return layer->id() == node->owner_id ? tree.parent(node)->id : node->id;
 }
 
 template <typename LayerType>
 static bool IsLayerBackFaceVisible(LayerType* layer,
                                    int transform_tree_index,
                                    const TransformTree& tree) {
   const TransformNode* node = tree.Node(transform_tree_index);
   return layer->use_local_transform_for_backface_visibility()
              ? node->local.IsBackFaceVisible()
-             : tree.ToTarget(transform_tree_index).IsBackFaceVisible();
+             : tree.ToTarget(transform_tree_index,
+                             layer->render_target_effect_tree_index())
+                   .IsBackFaceVisible();
 }
 
 static inline bool TransformToScreenIsKnown(Layer* layer,
                                             int transform_tree_index,
                                             const TransformTree& tree) {
   const TransformNode* node = tree.Node(transform_tree_index);
   return !node->to_screen_is_potentially_animated;
 }
 
 static inline bool TransformToScreenIsKnown(LayerImpl* layer,
@@ skipping 244 matching lines @@
           parent_to_current, parent_clip_node->clip_in_target_space);
     }
     // Only nodes affected by ancestor clips will have their clip adjusted due
     // to intersecting with an ancestor clip. But, we still need to propagate
     // the combined clip to our children because if they are clipped, they may
     // need to clip using our parent clip and if we don't propagate it here,
     // it will be lost.
     if (clip_node->resets_clip && non_root_surfaces_enabled) {
       if (clip_node->applies_local_clip) {
         clip_node->clip_in_target_space = MathUtil::MapClippedRect(
-            transform_tree.ToTarget(clip_node->transform_id), clip_node->clip);
+            transform_tree.ToTarget(clip_node->transform_id,
+                                    clip_node->target_effect_id),
+            clip_node->clip);
         ResetIfHasNanCoordinate(&clip_node->clip_in_target_space);
         clip_node->combined_clip_in_target_space =
             gfx::IntersectRects(clip_node->clip_in_target_space,
                                 parent_combined_clip_in_target_space);
       } else {
         DCHECK(!clip_node->target_is_clipped);
         DCHECK(!clip_node->layers_are_clipped);
         clip_node->combined_clip_in_target_space =
             parent_combined_clip_in_target_space;
       }
@@ skipping 15 matching lines @@
         // it to an empty rect.
         clip_node->clip_in_target_space = gfx::RectF();
       }
     } else {
       gfx::Transform source_to_target;
 
       if (!non_root_surfaces_enabled) {
         source_to_target = transform_tree.ToScreen(clip_node->transform_id);
       } else if (transform_tree.ContentTargetId(transform_node->id) ==
                  clip_node->target_transform_id) {
-        source_to_target = transform_tree.ToTarget(clip_node->transform_id);
+        source_to_target = transform_tree.ToTarget(clip_node->transform_id,
+                                                   clip_node->target_effect_id);
       } else {
         success = transform_tree.ComputeTransform(
             transform_node->id, clip_node->target_transform_id,
             &source_to_target);
         // We don't have to apply surface contents scale when target is root.
         if (clip_node->target_transform_id != 0) {
           const EffectNode* target_effect_node =
               effect_tree.Node(clip_node->target_effect_id);
           PostConcatSurfaceContentsScale(target_effect_node, &source_to_target);
 #if DCHECK_IS_ON()
@@ skipping 317 matching lines @@
 
 gfx::Transform DrawTransform(const LayerImpl* layer,
                              const TransformTree& transform_tree,
                              const EffectTree& effect_tree) {
   gfx::Transform xform;
   const bool owns_non_root_surface =
       !IsRootLayer(layer) && layer->has_render_surface();
   if (!owns_non_root_surface) {
     // If you're not the root, or you don't own a surface, you need to apply
     // your local offset.
-    xform = transform_tree.ToTarget(layer->transform_tree_index());
+    xform = transform_tree.ToTarget(layer->transform_tree_index(),
+                                    layer->render_target_effect_tree_index());
     if (layer->should_flatten_transform_from_property_tree())
       xform.FlattenTo2d();
     xform.Translate(layer->offset_to_transform_parent().x(),
                     layer->offset_to_transform_parent().y());
   } else {
     // Surfaces need to apply their surface contents scale.
     const EffectNode* effect_node =
         effect_tree.Node(layer->effect_tree_index());
     xform.Scale(effect_node->surface_contents_scale.x(),
                 effect_node->surface_contents_scale.y());
@@ skipping 375 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