cc: Re-use transforms from transform nodes when computing visible rects

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 <vector>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
@@ skipping 27 matching lines @@
       const TransformNode* clip_transform_node =
           transform_tree.Node(clip_node->data.transform_id);
       const bool target_is_root_surface =
           transform_node->data.content_target_id == 1;
       // When the target is the root surface, we need to include the root
       // transform by walking up to the root of the transform tree.
       const int target_id =
           target_is_root_surface ? 0 : transform_node->data.content_target_id;
       const TransformNode* target_node = transform_tree.Node(target_id);
 
-      // TODO(ajuma): Try to re-use transforms already stored in the transform
-      // tree instead of computing transforms below.
-      gfx::Transform content_to_target;
-      bool success = transform_tree.ComputeTransform(
-          transform_node->id, target_node->id, &content_to_target);
-      DCHECK(success);
+      gfx::Transform content_to_target = transform_node->data.to_target;
 
       content_to_target.Translate(layer->offset_to_transform_parent().x(),
                                   layer->offset_to_transform_parent().y());
       content_to_target.Scale(1.0 / contents_scale_x, 1.0 / contents_scale_y);
 
       gfx::Rect clip_rect_in_target_space;
       gfx::Transform clip_to_target;
-      success = transform_tree.ComputeTransform(
-          clip_transform_node->id, target_node->id, &clip_to_target);
+      bool success = true;
+      if (clip_transform_node->data.target_id == target_node->id) {
+        clip_to_target = clip_transform_node->data.to_target;
+      } else {
+        success = transform_tree.ComputeTransform(
+            clip_transform_node->id, target_node->id, &clip_to_target);
+        if (target_node->data.needs_sublayer_scale) {

[Ian Vollick, 2015/04/07 21:10:05]

aside: it would be really nice if we could tell ComputeTransform to include the
sublayer scale and not repeat this sort of code everywhere.

[ajuma, 2015/04/07 21:19:30]

Good idea, I'll do that in a follow-up.

+          clip_to_target.Scale(target_node->data.sublayer_scale.x(),
+                               target_node->data.sublayer_scale.y());
+        }
+      }
+
       if (target_node->id > clip_node->data.transform_id) {
         if (!success) {
           DCHECK(target_node->data.to_screen_is_animated);
 
           // 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_rect_from_property_trees(
               gfx::Rect(layer_content_bounds));
           continue;
@@ skipping 16 matching lines @@
                                             layer_content_rect);
       clip_rect_in_target_space.Intersect(layer_content_bounds_in_target_space);
       if (clip_rect_in_target_space.IsEmpty()) {
         layer->set_visible_rect_from_property_trees(gfx::Rect());
         continue;
       }
 
       gfx::Transform target_to_content;
       gfx::Transform target_to_layer;
 
-      success = transform_tree.ComputeTransform(
-          target_node->id, transform_node->id, &target_to_layer);
+      if (transform_node->data.ancestors_are_invertible) {
+        target_to_layer = transform_node->data.from_target;
+        success = true;
+      } else {
+        success = transform_tree.ComputeTransform(
+            target_node->id, transform_node->id, &target_to_layer);
+        if (target_node->data.needs_sublayer_scale) {
+          target_to_layer.matrix().postScale(
+              1.f / target_node->data.sublayer_scale.x(),
+              1.f / target_node->data.sublayer_scale.y(), 1.f);
+        }
+      }
+
       if (!success) {
         DCHECK(transform_node->data.to_screen_is_animated);
 
         // 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_rect_from_property_trees(
             gfx::Rect(layer_content_bounds));
         continue;
       }
@@ skipping 206 matching lines @@
 
   std::vector<Layer*> layers_to_update;
   const bool subtree_is_visible_from_ancestor = true;
   FindLayersThatNeedVisibleRects(root_layer, *transform_tree,
                                  subtree_is_visible_from_ancestor,
                                  &layers_to_update);
   CalculateVisibleRects(layers_to_update, *clip_tree, *transform_tree);
 }
 
 }  // namespace cc