cc : Cache trasnforms to target even when target is a descendant

cc/trees/property_tree.cc

Index: cc/trees/property_tree.cc
diff --git a/cc/trees/property_tree.cc b/cc/trees/property_tree.cc
index 0d1adb0857ba7ecd8d4fa470085a2fe6f287ee69..60d90d3d5b0f61947cc4d3b80f77594301a0b3b0 100644
--- a/cc/trees/property_tree.cc
+++ b/cc/trees/property_tree.cc
@@ -1949,38 +1949,69 @@ const DrawTransforms& PropertyTrees::GetDrawTransforms(int transform_id,
     gfx::Transform from_target;
     const TransformNode* transform_node = transform_tree.Node(transform_id);
     const EffectNode* effect_node = effect_tree.Node(effect_id);
+    const TransformNode* dest_node =
+        transform_tree.Node(effect_node->transform_id);
     DCHECK(effect_id == effect_tree.kRootNodeId ||
            effect_node->has_render_surface);
+    bool already_computed_inverse = false;
     if (transform_id == effect_node->transform_id) {
       target_space_transform.Scale(effect_node->surface_contents_scale.x(),
                                    effect_node->surface_contents_scale.y());
-    } else {
+    } else if (!dest_node || (dest_node->ancestors_are_invertible &&
+                              dest_node->node_and_ancestors_are_flat)) {
       // Compute transform from transform_id to effect_node->transform.
-      DCHECK_GT(transform_id, effect_node->transform_id);
-      const TransformNode* dest_node =
-          transform_tree.Node(effect_node->transform_id);
-      if (!dest_node || (dest_node->ancestors_are_invertible &&
-                         dest_node->node_and_ancestors_are_flat)) {
+      target_space_transform.ConcatTransform(
+          transform_tree.ToScreen(transform_id));
+      if (dest_node)
         target_space_transform.ConcatTransform(
-            transform_tree.ToScreen(transform_id));
-        if (dest_node)
-          target_space_transform.ConcatTransform(
-              transform_tree.FromScreen(dest_node->id));
-        if (dest_node->needs_surface_contents_scale)
-          target_space_transform.matrix().postScale(
-              dest_node->surface_contents_scale.x(),
-              dest_node->surface_contents_scale.y(), 1.f);
-      } else {
-        target_space_transform =
-            GetDrawTransforms(transform_node->parent_id, effect_id).to_target;
-        if (transform_node->flattens_inherited_transform)
-          target_space_transform.FlattenTo2d();
-        target_space_transform.PreconcatTransform(transform_node->to_parent);
+            transform_tree.FromScreen(dest_node->id));
+      if (dest_node->needs_surface_contents_scale)
+        target_space_transform.matrix().postScale(
+            dest_node->surface_contents_scale.x(),
+            dest_node->surface_contents_scale.y(), 1.f);
+    } else if (transform_node->id > dest_node->id) {
+      target_space_transform =
+          GetDrawTransforms(transform_node->parent_id, effect_id).to_target;
+      if (transform_node->flattens_inherited_transform)
+        target_space_transform.FlattenTo2d();
+      target_space_transform.PreconcatTransform(transform_node->to_parent);
+    } else {
+      const TransformNode* current = dest_node;
+      std::vector<int> source_to_destination;
+      source_to_destination.push_back(current->id);
+      current = transform_tree.parent(current);
+      for (; current && current->id > transform_node->id;
+           current = transform_tree.parent(current)) {
+        source_to_destination.push_back(current->id);
+      }
+      DCHECK_EQ(current, transform_node);
+      gfx::Transform combined_transform;
+      size_t source_to_destination_size = source_to_destination.size();
+      for (size_t i = 0; i < source_to_destination_size; ++i) {
+        size_t index = source_to_destination_size - 1 - i;
+        const TransformNode* node =
+            transform_tree.Node(source_to_destination[index]);
+        if (node->flattens_inherited_transform)
+          combined_transform.FlattenTo2d();
+        combined_transform.PreconcatTransform(node->to_parent);
       }
+      if (effect_node->surface_contents_scale.x() != 0.f &&
+          effect_node->surface_contents_scale.y() != 0.f)
+        combined_transform.Scale(
+            1.0f / effect_node->surface_contents_scale.x(),
+            1.0f / effect_node->surface_contents_scale.y());
+      cached_data_.draw_transforms[effect_id][transform_id]
+          .transforms.invertible =
+          combined_transform.GetInverse(&target_space_transform);
+      target_space_transform.PreconcatTransform(combined_transform);

[ajuma, 2016/08/11 23:17:56]

I'm probably missing something, but doesn't this line turn
target_space_transform into the identity?

[jaydasika, 2016/08/12 00:37:21]

Oops, my bad. I din't catch it as there are no unit tests that are hittihg this
path. Changed one of the tests to hit this path.

+      from_target = combined_transform;
+      already_computed_inverse = true;
+    }
+    if (!already_computed_inverse) {
+      cached_data_.draw_transforms[effect_id][transform_id]
+          .transforms.invertible =
+          target_space_transform.GetInverse(&from_target);
     }
-    cached_data_.draw_transforms[effect_id][transform_id]
-        .transforms.invertible =
-        target_space_transform.GetInverse(&from_target);
     cached_data_.draw_transforms[effect_id][transform_id].update_number =
         cached_data_.property_tree_update_number;
     cached_data_.draw_transforms[effect_id][transform_id]
@@ -2040,10 +2071,11 @@ bool PropertyTrees::ComputeTransformToTarget(int transform_id,
     target_transform_id = effect_node->transform_id;
   }
 
+  if (transform_id == TransformTree::kInvalidNodeId)
+    return true;
   bool success = transform_tree.ComputeTransform(
       transform_id, target_transform_id, transform);
-  if (verify_transform_tree_calculations &&
-      transform_id > target_transform_id) {
+  if (verify_transform_tree_calculations) {
     gfx::Transform to_target;
     to_target.ConcatTransform(
         GetDrawTransforms(transform_id, effect_id).to_target);
@@ -2078,8 +2110,7 @@ bool PropertyTrees::ComputeTransformFromTarget(
 
   bool success = transform_tree.ComputeTransform(target_transform_id,
                                                  transform_id, transform);
-  if (verify_transform_tree_calculations &&
-      transform_id < target_transform_id) {
+  if (verify_transform_tree_calculations) {
     auto draw_transforms = GetDrawTransforms(transform_id, effect_id);
     gfx::Transform from_target;
     from_target.ConcatTransform(draw_transforms.from_target);