cc : Split TransformTree::ComputeTransform

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 133 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) {
-    return CombineTransformsBetween(source_id, dest_id, transform);
+    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);
+  DCHECK(transform->IsIdentityOr2DTranslation());
+  return success;
+}
+
 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);
     node->transform_changed = false;
   }
@@ skipping 21 matching lines @@
 
 bool TransformTree::IsDescendant(int desc_id, int source_id) const {
   while (desc_id != source_id) {
     if (desc_id == kInvalidNodeId)
       return false;
     desc_id = Node(desc_id)->parent_id;
   }
   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);
   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
   // the destination. The expected result is C * B. But C's to_screen
   // transform is C * B * flattened(A * R), and A's from_screen transform is
   // R^{-1} * A^{-1}. If at least one of A and R isn't flat, the inverse of
   // flattened(A * R) won't be R^{-1} * A{-1}, so multiplying C's to_screen and
   // A's from_screen will not produce the correct result.
   if (!dest ||
       (dest->ancestors_are_invertible && dest->node_and_ancestors_are_flat)) {
     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
   // traversing downward in the tree. We first identify nodes that are on the
   // path from the source to the destination (this is traversing upward), and
   // then we visit these nodes in reverse order, flattening as needed. We
   // early-out if we get to a node whose target node is the destination, since
   // we can then re-use the target space transform stored at that node. However,
   // we cannot re-use a stored target space transform if the destination has a
   // zero surface contents scale, since stored target space transforms have
@@ skipping 50 matching lines @@
   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 = Node(source_to_destination[index]);
     if (node->flattens_inherited_transform)
       combined_transform.FlattenTo2d();
     combined_transform.PreconcatTransform(node->to_parent);
   }
 
   transform->ConcatTransform(combined_transform);
-  return true;
 }
 
 bool TransformTree::CombineInversesBetween(int source_id,
                                            int dest_id,
                                            gfx::Transform* transform) const {
   DCHECK(source_id < dest_id);
   const TransformNode* current = Node(dest_id);
   const TransformNode* dest = Node(source_id);
   // Just as in CombineTransformsBetween, we can use screen space transforms in
   // this computation only when there isn't any non-trivial flattening
@@ skipping 16 matching lines @@
   gfx::Transform source_to_dest;
   bool all_are_invertible = dest_to_source.GetInverse(&source_to_dest);
   transform->PreconcatTransform(source_to_dest);
   return all_are_invertible;
 }
 
 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);
+    ComputeTranslation(node->source_node_id, node->parent_id, &to_parent);
     node->source_to_parent = to_parent.To2dTranslation();
   }
 
   gfx::Vector2dF fixed_position_adjustment;
   gfx::Vector2dF inner_viewport_bounds_delta =
       property_trees()->inner_viewport_container_bounds_delta();
   gfx::Vector2dF outer_viewport_bounds_delta =
       property_trees()->outer_viewport_container_bounds_delta();
   if (node->affected_by_inner_viewport_bounds_delta_x)
     fixed_position_adjustment.set_x(inner_viewport_bounds_delta.x());
@@ skipping 1613 matching lines @@
     screen_space_transform.Scale(1.0 / effect_node->surface_contents_scale.x(),
                                  1.0 / effect_node->surface_contents_scale.y());
   return screen_space_transform;
 }
 
 bool PropertyTrees::ComputeTransformToTarget(int transform_id,
                                              int effect_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)
-    return true;
+  return transform_tree.ComputeTransform(transform_id, target_transform_id,
+                                         transform);
+}
 
-  if (transform_id > destination_transform_id) {
-    return transform_tree.CombineTransformsBetween(
-        transform_id, destination_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;
   }
 
-  return transform_tree.CombineInversesBetween(
-      transform_id, destination_transform_id, transform);
+  return transform_tree.ComputeTransform(target_transform_id, transform_id,
+                                         transform);
 }
 
 }  // namespace cc