cc: Compute draw transforms dynamically.

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 240 matching lines @@
   TransformNode* source_node = Node(node->source_node_id);
   property_trees()->UpdateCachedNumber();
   if (node->needs_local_transform_update || NeedsSourceToParentUpdate(node))
     UpdateLocalTransform(node);
   else
     UndoSnapping(node);
   UpdateScreenSpaceTransform(node, parent_node, target_node);
   UpdateSurfaceContentsScale(node);
   UpdateAnimationProperties(node, parent_node);
   UpdateSnapping(node);
-  UpdateTargetSpaceTransform(node, target_node);
+  if (!property_trees()->verify_transform_tree_calculations)
+    UpdateTargetSpaceTransform(node, target_node);
   UpdateNodeAndAncestorsHaveIntegerTranslations(node, parent_node);
   UpdateTransformChanged(node, parent_node, source_node);
   UpdateNodeAndAncestorsAreAnimatedOrInvertible(node, parent_node);
 }
 
 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;
@@ skipping 36 matching lines @@
   // surface contents scale baked in, but we need to compute an unscaled
   // transform.
   std::vector<int> source_to_destination;
   source_to_destination.push_back(current->id);
   current = parent(current);
   bool destination_has_non_zero_surface_contents_scale =
       dest->surface_contents_scale.x() != 0.f &&
       dest->surface_contents_scale.y() != 0.f;
   DCHECK(destination_has_non_zero_surface_contents_scale ||
          !dest->ancestors_are_invertible);
-  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;
+  for (; current && current->id > dest_id; current = parent(current))
     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);

[jaydasika, 2016/09/02 18:10:01]

This is not behind a flag. Is it fine to remove it from a performance standpoint
?

[sunxd, 2016/09/02 18:13:10]

Removing it does make performance suffer. I can make it only runs when the flag
is not enabled.

But after talking with Ali, I decide to remove the old path as well as the flag
in property trees, as it might be more clear to land the patch to execute the
new path rather than to land the patch and enable it later.

     // 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
     // corresponding to the layer's render target. For example, consider the
@@ skipping 322 matching lines @@
 
 bool TransformTree::HasNodesAffectedByOuterViewportBoundsDelta() const {
   return !nodes_affected_by_outer_viewport_bounds_delta_.empty();
 }
 
 const gfx::Transform& TransformTree::FromTarget(int node_id,
                                                 int effect_id) const {
   DCHECK(static_cast<int>(cached_data_.size()) > node_id);
   if (effect_id != kInvalidNodeId &&
       property_trees()->verify_transform_tree_calculations) {
-    const gfx::Transform& transform =
-        property_trees()->GetDrawTransforms(node_id, effect_id).from_target;
-    CHECK(transform.ApproximatelyEqual(cached_data_[node_id].from_target));
+    return property_trees()->GetDrawTransforms(node_id, effect_id).from_target;
   }
   return cached_data_[node_id].from_target;
 }
 
 void TransformTree::SetFromTarget(int node_id,
                                   const gfx::Transform& transform) {
   DCHECK(static_cast<int>(cached_data_.size()) > node_id);
   cached_data_[node_id].from_target = transform;
 }
 
 const gfx::Transform& TransformTree::ToTarget(int node_id,
                                               int effect_id) const {
   DCHECK(static_cast<int>(cached_data_.size()) > node_id);
   if (effect_id != kInvalidNodeId &&
       property_trees()->verify_transform_tree_calculations) {
-    const gfx::Transform& transform =
-        property_trees()->GetDrawTransforms(node_id, effect_id).to_target;
-    if (property_trees()->non_root_surfaces_enabled)
-      CHECK(transform.ApproximatelyEqual(cached_data_[node_id].to_target));
-    else
-      CHECK(transform.ApproximatelyEqual(cached_data_[node_id].to_screen));
+    return property_trees()->GetDrawTransforms(node_id, effect_id).to_target;
   }
   return cached_data_[node_id].to_target;
 }
 
 void TransformTree::SetToTarget(int node_id, const gfx::Transform& transform) {
   DCHECK(static_cast<int>(cached_data_.size()) > node_id);
   cached_data_[node_id].to_target = transform;
 }
 
 const gfx::Transform& TransformTree::FromScreen(int node_id) const {
@@ skipping 1232 matching lines @@
         !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.Node(transform_node_id)
-             ->to_parent.IsScaleOrTranslation();
+        !node->to_parent.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 169 matching lines @@
     cached_data_.draw_transforms[effect_id][transform_id].transforms.to_target =
         target_space_transform;
   }
   return cached_data_.draw_transforms[effect_id][transform_id].transforms;
 }
 
 void PropertyTrees::ResetCachedData() {
   cached_data_.property_tree_update_number = 0;
   cached_data_.animation_scales = std::vector<AnimationScaleData>(
       transform_tree.nodes().size(), AnimationScaleData());
-  cached_data_.draw_transforms =
-      std::vector<std::unordered_map<int, DrawTransformData>>(
-          effect_tree.nodes().size(),
-          std::unordered_map<int, DrawTransformData>());
+  cached_data_.draw_transforms = std::vector<std::map<int, DrawTransformData>>(
+      effect_tree.nodes().size(), std::map<int, DrawTransformData>());
 }
 
 void PropertyTrees::UpdateCachedNumber() {
   cached_data_.property_tree_update_number++;
 }
 
 gfx::Transform PropertyTrees::ToScreenSpaceTransformWithoutSurfaceContentsScale(
     int transform_id,
     int effect_id) const {
   DCHECK_GT(transform_id, 0);
@@ skipping 24 matching lines @@
     // 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 {
     DCHECK(effect_node->has_render_surface ||
            effect_node->id == EffectTree::kRootNodeId);
     target_transform_id = effect_node->transform_id;
   }
 
-  bool success = transform_tree.ComputeTransform(
-      transform_id, target_transform_id, transform);
+  bool success = true;
   if (verify_transform_tree_calculations) {
-    gfx::Transform to_target;
-    to_target.ConcatTransform(
-        GetDrawTransforms(transform_id, effect_id).to_target);
+    auto draw_transforms = GetDrawTransforms(transform_id, effect_id);
+    success = draw_transforms.invertible;
+    transform->ConcatTransform(draw_transforms.to_target);
     if (effect_node->surface_contents_scale.x() != 0.f &&
         effect_node->surface_contents_scale.y() != 0.f)
-      to_target.matrix().postScale(
+      transform->matrix().postScale(
           1.0f / effect_node->surface_contents_scale.x(),
           1.0f / effect_node->surface_contents_scale.y(), 1.0f);
-    DCHECK(to_target.ApproximatelyEqual(*transform));
+  } else {
+    success = transform_tree.ComputeTransform(transform_id, target_transform_id,
+                                              transform);
   }
   return success;
 }
 
 bool PropertyTrees::ComputeTransformFromTarget(
     int transform_id,
     int effect_id,
     gfx::Transform* transform) const {
   transform->MakeIdentity();
 
   if (transform_id == TransformTree::kInvalidNodeId)
     return true;
 
   int target_transform_id;
   const EffectNode* effect_node = effect_tree.Node(effect_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 {
     DCHECK(effect_node->has_render_surface ||
            effect_node->id == EffectTree::kRootNodeId);
     target_transform_id = effect_node->transform_id;
   }
 
-  bool success = transform_tree.ComputeTransform(target_transform_id,
-                                                 transform_id, transform);
+  bool success = true;
   if (verify_transform_tree_calculations) {
     auto draw_transforms = GetDrawTransforms(transform_id, effect_id);
-    gfx::Transform from_target;
-    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);
+    success = draw_transforms.invertible;
+    transform->ConcatTransform(draw_transforms.from_target);
+    transform->Scale(effect_node->surface_contents_scale.x(),
+                     effect_node->surface_contents_scale.y());
+  } else {
+    success = transform_tree.ComputeTransform(target_transform_id, transform_id,
+                                              transform);
   }
   return success;
 }
 
 }  // namespace cc