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

cc/trees/property_tree.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 <set>
 #include <vector>
 
 #include "base/logging.h"
 #include "cc/base/math_util.h"
 #include "cc/trees/property_tree.h"
@@ skipping 56 matching lines @@
 
   if (source_id > dest_id) {
     DCHECK(IsDescendant(source_id, dest_id));
     return CombineTransformsBetween(source_id, dest_id, transform);
   }
 
   DCHECK(IsDescendant(dest_id, source_id));
   return CombineInversesBetween(source_id, dest_id, transform);
 }
 
+bool TransformTree::ComputeTransformWithDestinationSublayerScale(
+    int source_id,
+    int dest_id,
+    gfx::Transform* transform) const {

[Ian Vollick, 2015/04/10 17:10:39]

Thank you very much for adding these. Would it make sense to try and use them in
Layer::draw_transform_from.. (in another cl)?

[ajuma, 2015/04/10 17:19:49]

It looks like that method only applies sublayer scale when it isn't
computing/reading any other transform, so these might not be a great fit over
there.

+  bool success = ComputeTransform(source_id, dest_id, transform);
+
+  const TransformNode* dest_node = Node(dest_id);
+  if (!dest_node->data.needs_sublayer_scale)
+    return success;
+
+  transform->matrix().postScale(dest_node->data.sublayer_scale.x(),
+                                dest_node->data.sublayer_scale.y(), 1.f);
+  return success;
+}
+
+bool TransformTree::ComputeTransformWithSourceSublayerScale(
+    int source_id,
+    int dest_id,
+    gfx::Transform* transform) const {
+  bool success = ComputeTransform(source_id, dest_id, transform);
+
+  const TransformNode* source_node = Node(source_id);
+  if (!source_node->data.needs_sublayer_scale)
+    return success;
+
+  transform->Scale(1.f / source_node->data.sublayer_scale.x(),
+                   1.f / source_node->data.sublayer_scale.y());
+  return success;
+}
+
 bool TransformTree::Are2DAxisAligned(int source_id, int dest_id) const {
   gfx::Transform transform;
   return ComputeTransform(source_id, dest_id, &transform) &&
          transform.Preserves2dAxisAlignment();
 }
 
 void TransformTree::UpdateTransforms(int id) {
   TransformNode* node = Node(id);
   TransformNode* parent_node = parent(node);
   TransformNode* target_node = Node(node->data.target_id);
@@ skipping 141 matching lines @@
   // The sublayer scale depends on the screen space transform, so update it too.
   node->data.sublayer_scale =
       node->data.needs_sublayer_scale
           ? MathUtil::ComputeTransform2dScaleComponents(
                 node->data.to_screen, node->data.layer_scale_factor)
           : gfx::Vector2dF(1.0f, 1.0f);
 }
 
 void TransformTree::UpdateTargetSpaceTransform(TransformNode* node,
                                                TransformNode* target_node) {
-  node->data.to_target.MakeIdentity();
   if (node->data.needs_sublayer_scale) {
+    node->data.to_target.MakeIdentity();
     node->data.to_target.Scale(node->data.sublayer_scale.x(),
                                node->data.sublayer_scale.y());
   } else {
     const bool target_is_root_surface = target_node->id == 1;
     // In order to include the root transform for the root surface, we walk up
     // to the root of the transform tree in ComputeTransform.
     int target_id = target_is_root_surface ? 0 : target_node->id;
-    if (target_node) {
-      node->data.to_target.Scale(target_node->data.sublayer_scale.x(),
-                                 target_node->data.sublayer_scale.y());
-    }
-
-    gfx::Transform unscaled_target_transform;
-    ComputeTransform(node->id, target_id, &unscaled_target_transform);
-    node->data.to_target.PreconcatTransform(unscaled_target_transform);
+    ComputeTransformWithDestinationSublayerScale(node->id, target_id,
+                                                 &node->data.to_target);
   }
 
   if (!node->data.to_target.GetInverse(&node->data.from_target))
     node->data.ancestors_are_invertible = false;
 }
 
 void TransformTree::UpdateIsAnimated(TransformNode* node,
                                      TransformNode* parent_node) {
   if (parent_node) {
     node->data.to_screen_is_animated =
@@ skipping 30 matching lines @@
   node->data.from_target.matrix().postTranslate(-translation.x(),
                                                 -translation.y(), 0);
   node->data.to_screen.Translate(translation.x(), translation.y());
   node->data.from_screen.matrix().postTranslate(-translation.x(),
                                                 -translation.y(), 0);
 
   node->data.scroll_snap = translation;
 }
 
 }  // namespace cc