cc : Split TransformTree::ComputeTransform

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 29ac85b1c4c06cefa91c436e9259b00751fc57f6..75f727369e6259b126e20181d009b2d641c155a9 100644
--- a/cc/trees/property_tree.cc
+++ b/cc/trees/property_tree.cc
@@ -151,7 +151,25 @@ bool TransformTree::ComputeTransform(int source_id,
     return true;
 
   if (source_id > dest_id) {
-    return CombineTransformsBetween(source_id, dest_id, transform);
+    CombineTransformsBetween(source_id, dest_id, transform);
+    return true;
+  }
+
+  return CombineInversesBetween(source_id, dest_id, transform);
+}
+
+bool TransformTree::ComputeTransformFromSourceToParent(

[ajuma, 2016/07/27 15:57:11]

Since this currently has essentially the same implementation as
ComputeTransform, can the common parts go into a helper function for now?

[jaydasika, 2016/07/27 18:42:23]

Done.

+    int source_id,
+    int dest_id,
+    gfx::Transform* transform) const {
+  transform->MakeIdentity();
+
+  if (source_id == dest_id)
+    return true;
+
+  if (source_id > dest_id) {
+    CombineTransformsBetween(source_id, dest_id, transform);
+    return true;
   }
 
   return CombineInversesBetween(source_id, dest_id, transform);
@@ -198,7 +216,7 @@ bool TransformTree::IsDescendant(int desc_id, int source_id) const {
   return true;
 }
 
-bool TransformTree::CombineTransformsBetween(int source_id,
+void TransformTree::CombineTransformsBetween(int source_id,
                                              int dest_id,
                                              gfx::Transform* transform) const {
   DCHECK(source_id > dest_id);
@@ -219,7 +237,7 @@ bool TransformTree::CombineTransformsBetween(int source_id,
     transform->ConcatTransform(ToScreen(current->id));
     if (dest)
       transform->ConcatTransform(FromScreen(dest->id));
-    return true;
+    return;
   }
 
   // Flattening is defined in a way that requires it to be applied while
@@ -290,7 +308,6 @@ bool TransformTree::CombineTransformsBetween(int source_id,
   }
 
   transform->ConcatTransform(combined_transform);
-  return true;
 }
 
 bool TransformTree::CombineInversesBetween(int source_id,
@@ -327,7 +344,8 @@ void TransformTree::UpdateLocalTransform(TransformNode* node) {
   gfx::Transform transform = node->post_local;
   if (NeedsSourceToParentUpdate(node)) {
     gfx::Transform to_parent;
-    ComputeTransform(node->source_node_id, node->parent_id, &to_parent);
+    ComputeTransformFromSourceToParent(node->source_node_id, node->parent_id,
+                                       &to_parent);
     node->source_to_parent = to_parent.To2dTranslation();
   }
 
@@ -1961,29 +1979,62 @@ bool PropertyTrees::ComputeTransformToTarget(int transform_id,
                                              gfx::Transform* transform) const {
   transform->MakeIdentity();
 
-  int destination_transform_id;
+  int target_transform_id;
   if (effect_id == EffectTree::kInvalidNodeId) {
     // This can happen when PaintArtifactCompositor builds property trees as
     // it doesn't set effect ids on clip nodes. We want to compute transform
     // to the root in this case.
-    destination_transform_id = TransformTree::kRootNodeId;
+    target_transform_id = TransformTree::kRootNodeId;
   } else {
     const EffectNode* effect_node = effect_tree.Node(effect_id);
     DCHECK(effect_node->has_render_surface ||
            effect_node->id == EffectTree::kRootNodeId);
-    destination_transform_id = effect_node->transform_id;
+    target_transform_id = effect_node->transform_id;
   }
 
-  if (transform_id == destination_transform_id)
+  if (transform_id == target_transform_id)
     return true;
 
-  if (transform_id > destination_transform_id) {
-    return transform_tree.CombineTransformsBetween(
-        transform_id, destination_transform_id, transform);
+  if (transform_id > target_transform_id) {
+    transform_tree.CombineTransformsBetween(transform_id, target_transform_id,
+                                            transform);
+    return true;
   }
 
-  return transform_tree.CombineInversesBetween(
-      transform_id, destination_transform_id, transform);
+  return transform_tree.CombineInversesBetween(transform_id,
+                                               target_transform_id, transform);
+}
+
+bool PropertyTrees::ComputeTransformFromTarget(
+    int transform_id,
+    int effect_id,
+    gfx::Transform* transform) const {
+  transform->MakeIdentity();
+
+  int target_transform_id;
+  if (effect_id == EffectTree::kInvalidNodeId) {
+    // This can happen when PaintArtifactCompositor builds property trees as
+    // it doesn't set effect ids on clip nodes. We want to compute transform
+    // to the root in this case.
+    target_transform_id = TransformTree::kRootNodeId;
+  } else {
+    const EffectNode* effect_node = effect_tree.Node(effect_id);
+    DCHECK(effect_node->has_render_surface ||
+           effect_node->id == EffectTree::kRootNodeId);
+    target_transform_id = effect_node->transform_id;
+  }
+
+  if (transform_id == target_transform_id)
+    return true;
+
+  if (transform_id > target_transform_id) {
+    return transform_tree.CombineInversesBetween(target_transform_id,
+                                                 transform_id, transform);
+  }
+
+  transform_tree.CombineTransformsBetween(target_transform_id, transform_id,
+                                          transform);
+  return true;
 }
 
 }  // namespace cc