cc: Compute draw transforms correctly when non root surfaces disabled

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 242 matching lines @@
   for (; current && current->id > dest_id; current = parent(current)) {
     if (destination_has_non_zero_surface_contents_scale &&
         TargetId(current->id) == dest_id &&
         ContentTargetId(current->id) == dest_id)
       break;
     source_to_destination.push_back(current->id);
   }
 
   gfx::Transform combined_transform;
   if (current->id > dest_id) {
+    // TODO(sunxd): Instead of using target space transform, only use to_parent
+    // here when we fully implement computing draw transforms on demand.
     combined_transform = ToTarget(current->id, kInvalidNodeId);
     // The stored target space transform has surface contents scale baked in,
     // but we need the unscaled transform.
     combined_transform.matrix().postScale(
         1.0f / dest->surface_contents_scale.x(),
         1.0f / dest->surface_contents_scale.y(), 1.0f);
   } else if (current->id < dest_id) {
     // We have reached the lowest common ancestor of the source and destination
     // nodes. This case can occur when we are transforming between a node
     // corresponding to a fixed-position layer (or its descendant) and the node
@@ skipping 1518 matching lines @@
         .to_screen_has_scale_animation =
         !node->has_only_translation_animations || ancestor_is_animating_scale;
 
     // Once we've failed to compute a maximum animated scale at an ancestor, we
     // continue to fail.
     bool failed_at_ancestor =
         ancestor_is_animating_scale && ancestor_maximum_target_scale == 0.f;
 
     // Computing maximum animated scale in the presence of non-scale/translation
     // transforms isn't supported.
-    bool failed_for_non_scale_or_translation =
-        !transform_tree.ToTarget(transform_node_id, effect_tree.kInvalidNodeId)
-             .IsScaleOrTranslation();
+    bool failed_for_non_scale_or_translation = false;
+    if (node && node->id != transform_tree.kRootNodeId)

[ajuma, 2016/08/04 22:55:58]

Is |node| ever null here? Can we just use |transform_node_id|?

[sunxd, 2016/08/05 15:40:42]

Done.

+      failed_for_non_scale_or_translation =
+          !transform_tree
+               .ToTarget(transform_node_id,

[ajuma, 2016/08/04 22:55:58]

Hmm. Do we need to use ToTarget here? What about using ToParent instead? If any
ancestor has a non-scale-or-translation transform, the code below should already
ensure that we fail to compute animation scales, so I think we only need to
handle the case of the node itself having a non-scale-or-translation.

[sunxd, 2016/08/05 15:40:42]

Done.

+                         layer_tree_impl->LayerById(node->owner_id)
+                             ->render_target_effect_tree_index())

[ajuma, 2016/08/04 22:55:58]

If we really do need this, it'd be better to pass it in rather than adding a
dependency on LayerImpl.

[sunxd, 2016/08/05 15:40:42]

Done.

+               .IsScaleOrTranslation();
 
     // We don't attempt to accumulate animation scale from multiple nodes with
     // scale animations, because of the risk of significant overestimation. For
     // example, one node might be increasing scale from 1 to 10 at the same time
     // as another node is decreasing scale from 10 to 1. Naively combining these
     // scales would produce a scale of 100.
     bool failed_for_multiple_scale_animations =
         ancestor_is_animating_scale && !node->has_only_translation_animations;
 
     if (failed_at_ancestor || failed_for_non_scale_or_translation ||
@@ skipping 44 matching lines @@
                   .local_starting_animation_scale == 0.f ||
           cached_data_.animation_scales[transform_node_id]
                   .local_maximum_animation_target_scale == 0.f) {
         cached_data_.animation_scales[transform_node_id]
             .combined_maximum_animation_target_scale =
             max_local_scale * ancestor_maximum_target_scale;
         cached_data_.animation_scales[transform_node_id]
             .combined_starting_animation_scale =
             max_local_scale * ancestor_starting_animation_scale;
       } else {
-        gfx::Vector2dF ancestor_scales =
-            parent_node ? MathUtil::ComputeTransform2dScaleComponents(
-                              transform_tree.ToTarget(
-                                  parent_node->id, effect_tree.kInvalidNodeId),
-                              0.f)
-                        : gfx::Vector2dF(1.f, 1.f);
+        gfx::Vector2dF ancestor_scales = gfx::Vector2dF(1.f, 1.f);
+        if (parent_node && parent_node->id != transform_tree.kRootNodeId)
+          ancestor_scales = MathUtil::ComputeTransform2dScaleComponents(
+              transform_tree.ToTarget(

[ajuma, 2016/08/04 22:55:58]

I think we might be able to use ToScreen here (since the scale components of
ToTarget and ToScreen should be the same).

[sunxd, 2016/08/05 15:40:42]

Done.

+                  parent_node->id,
+                  layer_tree_impl->LayerById(parent_node->owner_id)
+                      ->render_target_effect_tree_index()),
+              0.f);
         float max_ancestor_scale =
             std::max(ancestor_scales.x(), ancestor_scales.y());
         cached_data_.animation_scales[transform_node_id]
             .combined_maximum_animation_target_scale =
             max_ancestor_scale *
             cached_data_.animation_scales[transform_node_id]
                 .local_maximum_animation_target_scale;
         cached_data_.animation_scales[transform_node_id]
             .combined_starting_animation_scale =
             max_ancestor_scale *
@@ skipping 166 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