Reland use screen space transform to compute translation

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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 143 matching lines @@
     CombineTransformsBetween(source_id, dest_id, transform);
     return true;
   }
 
   return CombineInversesBetween(source_id, dest_id, transform);
 }
 
 bool TransformTree::ComputeTranslation(int source_id,
                                        int dest_id,
                                        gfx::Transform* transform) const {
-  bool success = ComputeTransform(source_id, dest_id, transform);
+  transform->MakeIdentity();
+  if (source_id == dest_id)
+    return true;
+
+  const TransformNode* dest = Node(dest_id);
+  if (!dest->ancestors_are_invertible)
+    return false;
+  if (source_id != kInvalidNodeId)
+    transform->ConcatTransform(ToScreen(source_id));
+  if (dest_id != kInvalidNodeId) {
+    if (dest->local.IsFlat() && (dest->node_and_ancestors_are_flat ||
+                                 dest->flattens_inherited_transform)) {
+      // In this case, flattenning will not affect the result, so we can use the
+      // FromScreen transform of the dest node.
+      transform->ConcatTransform(FromScreen(dest_id));
+    } else {
+      // In this case, some node between source and destination flattens
+      // inherited transform. Consider the tree R->A->B->C->D, where D is the
+      // source, A is the destination and C flattens inherited transform. The
+      // expected result is D * C * flattened(B). D's ToScreen will be D * C *
+      // flattened(B * A * R), but as the source to destination transform is
+      // at most translation, C and B cannot be non-flat and so flattened(B * A
+      // * R) = B * flattened(A * R). So, to get the expected result we have to
+      // multiply D's ToScreen transform with flattened(A * R)^{-1}, which is
+      // the inverse of flattened ToScreen of destination.
+      gfx::Transform to_screen = ToScreen(dest_id);
+      to_screen.FlattenTo2d();
+      gfx::Transform from_screen;
+      bool success = to_screen.GetInverse(&from_screen);
+      if (!success)
+        return false;
+      transform->ConcatTransform(from_screen);
+    }
+  }
+
   DCHECK(
       transform->IsApproximatelyIdentityOrTranslation(SkDoubleToMScalar(1e-4)));
-  return success;
+  return true;
 }
 
 bool TransformTree::NeedsSourceToParentUpdate(TransformNode* node) {
   return (source_to_parent_updates_allowed() &&
           node->parent_id != node->source_node_id);
 }
 
 void TransformTree::ResetChangeTracking() {
   for (int id = 1; id < static_cast<int>(size()); ++id) {
     TransformNode* node = Node(id);
@@ skipping 1873 matching lines @@
     from_target.ConcatTransform(draw_transforms.from_target);
     from_target.Scale(effect_node->surface_contents_scale.x(),
                       effect_node->surface_contents_scale.y());
     DCHECK(from_target.ApproximatelyEqual(*transform) ||
            !draw_transforms.invertible);
   }
   return success;
 }
 
 }  // namespace cc