cc : Split TransformTree::ComputeTransform

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 137 matching lines @@
   bool is_clipped;
   gfx::RectF clip_rect;
 };
 
 static ConditionalClip ComputeTargetRectInLocalSpace(
     gfx::RectF rect,
     const PropertyTrees* property_trees,
     int target_transform_id,
     int local_transform_id,
     const int target_effect_id) {
-  const TransformTree& transform_tree = property_trees->transform_tree;
   const EffectTree& effect_tree = property_trees->effect_tree;
   gfx::Transform target_to_local;
-  bool success = transform_tree.ComputeTransform(
-      target_transform_id, local_transform_id, &target_to_local);
+  bool success = property_trees->ComputeTransformFromTarget(
+      local_transform_id, target_effect_id, &target_to_local);
   if (!success)
     // If transform is not invertible, cannot apply clip.
     return ConditionalClip{false, gfx::RectF()};
   const EffectNode* target_effect_node = effect_tree.Node(target_effect_id);
   ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_local);
 
   if (target_transform_id > local_transform_id)
     return ConditionalClip{true,  // is_clipped.
                            MathUtil::MapClippedRect(target_to_local, rect)};
 
@@ skipping 341 matching lines @@
     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, layer->render_target_effect_tree_index());
     } else {
-      bool success = transform_tree.ComputeTransform(
-          target_node_id, transform_node->id, &target_to_layer);
+      const EffectNode* target_effect_node =
+          ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree);
+      bool success = property_trees->ComputeTransformFromTarget(
+          transform_node->id, target_effect_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;
       }
-      const EffectNode* target_effect_node =
-          ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree);
       if (target_effect_node->id != EffectTree::kContentsRootNodeId) {
         ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_layer);
 #if DCHECK_IS_ON()
         VerifySurfaceContentsScalesMatch(target_effect_node->id, target_node_id,
                                          effect_tree, transform_tree);
 #endif
       }
     }
     gfx::Transform target_to_content;
     target_to_content.Translate(-layer->offset_to_transform_parent().x(),
@@ skipping 1060 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