Only allow change-of-basis between transform nodes on the same ancestor chain

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 47 matching lines @@
 }
 
 bool TransformTree::ComputeTransform(int source_id,
                                      int dest_id,
                                      gfx::Transform* transform) const {
   transform->MakeIdentity();
 
   if (source_id == dest_id)
     return true;
 
-  if (source_id > dest_id && IsDescendant(source_id, dest_id))
+  if (source_id > dest_id) {
+    DCHECK(IsDescendant(source_id, dest_id));
     return CombineTransformsBetween(source_id, dest_id, transform);
+  }
 
-  if (dest_id > source_id && IsDescendant(dest_id, source_id))
-    return CombineInversesBetween(source_id, dest_id, transform);
-
-  int lca = LowestCommonAncestor(source_id, dest_id);
-
-  bool no_singular_matrices_to_lca =
-      CombineTransformsBetween(source_id, lca, transform);
-
-  bool no_singular_matrices_from_lca =
-      CombineInversesBetween(lca, dest_id, transform);
-
-  return no_singular_matrices_to_lca && no_singular_matrices_from_lca;
+  DCHECK(IsDescendant(dest_id, source_id));
+  return CombineInversesBetween(source_id, dest_id, transform);
 }
 
 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);
@@ skipping 10 matching lines @@
 
 bool TransformTree::IsDescendant(int desc_id, int source_id) const {
   while (desc_id != source_id) {
     if (desc_id < 0)
       return false;
     desc_id = Node(desc_id)->parent_id;
   }
   return true;
 }
 
-int TransformTree::LowestCommonAncestor(int a, int b) const {
-  std::set<int> chain_a;
-  std::set<int> chain_b;
-  while (a || b) {
-    if (a) {
-      a = Node(a)->parent_id;
-      if (a > -1 && chain_b.find(a) != chain_b.end())
-        return a;
-      chain_a.insert(a);
-    }
-    if (b) {
-      b = Node(b)->parent_id;
-      if (b > -1 && chain_a.find(b) != chain_a.end())
-        return b;
-      chain_b.insert(b);
-    }
-  }
-  NOTREACHED();
-  return 0;
-}
-
 bool TransformTree::CombineTransformsBetween(int source_id,
                                              int dest_id,
                                              gfx::Transform* transform) const {
   const TransformNode* current = Node(source_id);
   const TransformNode* dest = Node(dest_id);
   // Combine transforms to and from the screen when possible. Since flattening
   // is a non-linear operation, we cannot use this approach when there is
   // non-trivial flattening between the source and destination nodes. For
   // example, consider the tree R->A->B->C, where B flattens its inherited
   // transform, and A has a non-flat transform. Suppose C is the source and A is
@@ skipping 180 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