cc: Compute animation scale on demand

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 161 matching lines @@
       node_and_ancestors_are_flat(true),
       node_and_ancestors_have_only_integer_translation(true),
       scrolls(false),
       needs_sublayer_scale(false),
       affected_by_inner_viewport_bounds_delta_x(false),
       affected_by_inner_viewport_bounds_delta_y(false),
       affected_by_outer_viewport_bounds_delta_x(false),
       affected_by_outer_viewport_bounds_delta_y(false),
       in_subtree_of_page_scale_layer(false),
       transform_changed(false),
-      post_local_scale_factor(1.0f),
-      local_maximum_animation_target_scale(0.f),
-      local_starting_animation_scale(0.f),
-      combined_maximum_animation_target_scale(0.f),
-      combined_starting_animation_scale(0.f) {}
+      post_local_scale_factor(1.0f) {}
 
 TransformNodeData::TransformNodeData(const TransformNodeData& other) = default;
 
 TransformNodeData::~TransformNodeData() {
 }
 
 bool TransformNodeData::operator==(const TransformNodeData& other) const {
   return pre_local == other.pre_local && local == other.local &&
          post_local == other.post_local && to_parent == other.to_parent &&
          source_node_id == other.source_node_id &&
@@ skipping 21 matching lines @@
          affected_by_inner_viewport_bounds_delta_y ==
              other.affected_by_inner_viewport_bounds_delta_y &&
          affected_by_outer_viewport_bounds_delta_x ==
              other.affected_by_outer_viewport_bounds_delta_x &&
          affected_by_outer_viewport_bounds_delta_y ==
              other.affected_by_outer_viewport_bounds_delta_y &&
          in_subtree_of_page_scale_layer ==
              other.in_subtree_of_page_scale_layer &&
          transform_changed == other.transform_changed &&
          post_local_scale_factor == other.post_local_scale_factor &&
-         local_maximum_animation_target_scale ==
-             other.local_maximum_animation_target_scale &&
-         local_starting_animation_scale ==
-             other.local_starting_animation_scale &&
-         combined_maximum_animation_target_scale ==
-             other.combined_maximum_animation_target_scale &&
-         combined_starting_animation_scale ==
-             other.combined_starting_animation_scale &&
          sublayer_scale == other.sublayer_scale &&
          scroll_offset == other.scroll_offset &&
          scroll_snap == other.scroll_snap &&
          source_offset == other.source_offset &&
          source_to_parent == other.source_to_parent;
 }
 
 void TransformNodeData::update_pre_local_transform(
     const gfx::Point3F& transform_origin) {
   pre_local.MakeIdentity();
@@ skipping 53 matching lines @@
   data->set_affected_by_inner_viewport_bounds_delta_y(
       affected_by_inner_viewport_bounds_delta_y);
   data->set_affected_by_outer_viewport_bounds_delta_x(
       affected_by_outer_viewport_bounds_delta_x);
   data->set_affected_by_outer_viewport_bounds_delta_y(
       affected_by_outer_viewport_bounds_delta_y);
 
   data->set_in_subtree_of_page_scale_layer(in_subtree_of_page_scale_layer);
   data->set_transform_changed(transform_changed);
   data->set_post_local_scale_factor(post_local_scale_factor);
-  data->set_local_maximum_animation_target_scale(
-      local_maximum_animation_target_scale);
-  data->set_local_starting_animation_scale(local_starting_animation_scale);
-  data->set_combined_maximum_animation_target_scale(
-      combined_maximum_animation_target_scale);
-  data->set_combined_starting_animation_scale(
-      combined_starting_animation_scale);
 
   Vector2dFToProto(sublayer_scale, data->mutable_sublayer_scale());
   ScrollOffsetToProto(scroll_offset, data->mutable_scroll_offset());
   Vector2dFToProto(scroll_snap, data->mutable_scroll_snap());
   Vector2dFToProto(source_offset, data->mutable_source_offset());
   Vector2dFToProto(source_to_parent, data->mutable_source_to_parent());
 }
 
 void TransformNodeData::FromProtobuf(const proto::TreeNode& proto) {
   DCHECK(proto.has_transform_node_data());
@@ skipping 35 matching lines @@
   affected_by_inner_viewport_bounds_delta_y =
       data.affected_by_inner_viewport_bounds_delta_y();
   affected_by_outer_viewport_bounds_delta_x =
       data.affected_by_outer_viewport_bounds_delta_x();
   affected_by_outer_viewport_bounds_delta_y =
       data.affected_by_outer_viewport_bounds_delta_y();
 
   in_subtree_of_page_scale_layer = data.in_subtree_of_page_scale_layer();
   transform_changed = data.transform_changed();
   post_local_scale_factor = data.post_local_scale_factor();
-  local_maximum_animation_target_scale =
-      data.local_maximum_animation_target_scale();
-  local_starting_animation_scale = data.local_starting_animation_scale();
-  combined_maximum_animation_target_scale =
-      data.combined_maximum_animation_target_scale();
-  combined_starting_animation_scale = data.combined_starting_animation_scale();
 
   sublayer_scale = ProtoToVector2dF(data.sublayer_scale());
   scroll_offset = ProtoToScrollOffset(data.scroll_offset());
   scroll_snap = ProtoToVector2dF(data.scroll_snap());
   source_offset = ProtoToVector2dF(data.source_offset());
   source_to_parent = ProtoToVector2dF(data.source_to_parent());
 }
 
 void TransformNodeData::AsValueInto(
     base::trace_event::TracedValue* value) const {
@@ skipping 344 matching lines @@
 
 void TransformTree::clear() {
   PropertyTree<TransformNode>::clear();
 
   nodes_affected_by_inner_viewport_bounds_delta_.clear();
   nodes_affected_by_outer_viewport_bounds_delta_.clear();
   cached_data_.clear();
   cached_data_.push_back(TransformCachedNodeData());
 }
 
+void TransformTree::set_needs_update(bool needs_update) {
+  if (needs_update && !PropertyTree::needs_update())
+    property_trees()->UpdateCachedNumber();
+  PropertyTree::set_needs_update(needs_update);
+}
+
 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);
@@ skipping 302 matching lines @@
   if (!target_space_transform.GetInverse(&from_target))
     node->data.ancestors_are_invertible = false;
   SetToTarget(node->id, target_space_transform);
   SetFromTarget(node->id, from_target);
 }
 
 void TransformTree::UpdateAnimationProperties(TransformNode* node,
                                               TransformNode* parent_node) {
   bool ancestor_is_animating = false;
   bool ancestor_is_animating_scale = false;
-  float ancestor_maximum_target_scale = 0.f;
-  float ancestor_starting_animation_scale = 0.f;
   if (parent_node) {
     ancestor_is_animating = parent_node->data.to_screen_is_potentially_animated;
     ancestor_is_animating_scale =
         parent_node->data.to_screen_has_scale_animation;
-    ancestor_maximum_target_scale =
-        parent_node->data.combined_maximum_animation_target_scale;
-    ancestor_starting_animation_scale =
-        parent_node->data.combined_starting_animation_scale;
   }
   node->data.to_screen_is_potentially_animated =
       node->data.has_potential_animation || ancestor_is_animating;
   node->data.to_screen_has_scale_animation =
       !node->data.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 =
-      !ToTarget(node->id).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->data.has_only_translation_animations;
-
-  if (failed_at_ancestor || failed_for_non_scale_or_translation ||
-      failed_for_multiple_scale_animations) {
-    node->data.combined_maximum_animation_target_scale = 0.f;
-    node->data.combined_starting_animation_scale = 0.f;
-
-    // This ensures that descendants know we've failed to compute a maximum
-    // animated scale.
-    node->data.to_screen_has_scale_animation = true;
-    return;
-  }
-
-  if (!node->data.to_screen_has_scale_animation) {
-    node->data.combined_maximum_animation_target_scale = 0.f;
-    node->data.combined_starting_animation_scale = 0.f;
-    return;
-  }
-
-  // At this point, we know exactly one of this node or an ancestor is animating
-  // scale.
-  if (node->data.has_only_translation_animations) {
-    // An ancestor is animating scale.
-    gfx::Vector2dF local_scales =
-        MathUtil::ComputeTransform2dScaleComponents(node->data.local, 0.f);
-    float max_local_scale = std::max(local_scales.x(), local_scales.y());
-    node->data.combined_maximum_animation_target_scale =
-        max_local_scale * ancestor_maximum_target_scale;
-    node->data.combined_starting_animation_scale =
-        max_local_scale * ancestor_starting_animation_scale;
-    return;
-  }
-
-  if (node->data.local_starting_animation_scale == 0.f ||
-      node->data.local_maximum_animation_target_scale == 0.f) {
-    node->data.combined_maximum_animation_target_scale = 0.f;
-    node->data.combined_starting_animation_scale = 0.f;
-    return;
-  }
-
-  gfx::Vector2dF ancestor_scales =
-      parent_node ? MathUtil::ComputeTransform2dScaleComponents(
-                        ToTarget(parent_node->id), 0.f)
-                  : gfx::Vector2dF(1.f, 1.f);
-  float max_ancestor_scale = std::max(ancestor_scales.x(), ancestor_scales.y());
-  node->data.combined_maximum_animation_target_scale =
-      max_ancestor_scale * node->data.local_maximum_animation_target_scale;
-  node->data.combined_starting_animation_scale =
-      max_ancestor_scale * node->data.local_starting_animation_scale;
 }
 
 void TransformTree::UndoSnapping(TransformNode* node) {
   // to_parent transform has the scroll snap from previous frame baked in.
   // We need to undo it and use the un-snapped transform to compute current
   // target and screen space transforms.
   node->data.to_parent.Translate(-node->data.scroll_snap.x(),
                                  -node->data.scroll_snap.y());
 }
 
@@ skipping 986 matching lines @@
 }
 
 gfx::ScrollOffset ScrollTree::ClampScrollOffsetToLimits(
     gfx::ScrollOffset offset,
     ScrollNode* scroll_node) const {
   offset.SetToMin(MaxScrollOffset(scroll_node->id));
   offset.SetToMax(gfx::ScrollOffset());
   return offset;
 }
 
+PropertyTreesCachedData::PropertyTreesCachedData()
+    : property_tree_update_number(0) {
+  animation_scales.clear();
+}
+
+PropertyTreesCachedData::~PropertyTreesCachedData() {}
+
 PropertyTrees::PropertyTrees()
     : needs_rebuild(true),
       non_root_surfaces_enabled(true),
       changed(false),
       full_tree_damaged(false),
       sequence_number(0),
       is_main_thread(true),
       is_active(false) {
   transform_tree.SetPropertyTrees(this);
   effect_tree.SetPropertyTrees(this);
@@ skipping 42 matching lines @@
   inner_viewport_container_bounds_delta_ =
       from.inner_viewport_container_bounds_delta();
   outer_viewport_container_bounds_delta_ =
       from.outer_viewport_container_bounds_delta();
   inner_viewport_scroll_bounds_delta_ =
       from.inner_viewport_scroll_bounds_delta();
   transform_tree.SetPropertyTrees(this);
   effect_tree.SetPropertyTrees(this);
   clip_tree.SetPropertyTrees(this);
   scroll_tree.SetPropertyTrees(this);
+  ResetCachedData();
   return *this;
 }
 
 void PropertyTrees::ToProtobuf(proto::PropertyTrees* proto) const {
   // TODO(khushalsagar): Add support for sending diffs when serializaing
   // property trees. See crbug/555370.
   transform_tree.ToProtobuf(proto->mutable_transform_tree());
   effect_tree.ToProtobuf(proto->mutable_effect_tree());
   clip_tree.ToProtobuf(proto->mutable_clip_tree());
   scroll_tree.ToProtobuf(proto->mutable_scroll_tree());
@@ skipping 162 matching lines @@
   clip_tree.AsValueInto(value.get());
   value->EndDictionary();
 
   value->BeginDictionary("scroll_tree");
   scroll_tree.AsValueInto(value.get());
   value->EndDictionary();
 
   return value;
 }
 
+CombinedAnimationScale PropertyTrees::GetAnimationScales(
+    int transform_node_id,
+    LayerTreeImpl* layer_tree_impl) {
+  if (cached_data_.animation_scales[transform_node_id].update_number !=
+      cached_data_.property_tree_update_number) {
+    TransformNode* node = transform_tree.Node(transform_node_id);
+    TransformNode* parent_node = transform_tree.parent(node);
+    bool ancestor_is_animating_scale = false;
+    float ancestor_maximum_target_scale = 0.f;
+    float ancestor_starting_animation_scale = 0.f;
+    if (parent_node) {
+      ancestor_is_animating_scale =
+          parent_node->data.to_screen_has_scale_animation;
+      CombinedAnimationScale combined_animation_scale = GetAnimationScales(
+          transform_tree.Node(transform_node_id)->parent_id, layer_tree_impl);
+      ancestor_maximum_target_scale =
+          combined_animation_scale.maximum_animation_scale;
+      ancestor_starting_animation_scale =
+          combined_animation_scale.starting_animation_scale;
+    }
+
+    bool failed_at_ancestor =
+        ancestor_is_animating_scale && ancestor_maximum_target_scale == 0.f;
+    bool failed_for_non_scale_or_translation =
+        !transform_tree.ToTarget(transform_node_id).IsScaleOrTranslation();
+    bool failed_for_multiple_scale_animations =
+        ancestor_is_animating_scale &&
+        !node->data.has_only_translation_animations;
+
+    if (failed_at_ancestor || failed_for_non_scale_or_translation ||
+        failed_for_multiple_scale_animations) {
+      node->data.to_screen_has_scale_animation = true;

[ajuma, 2016/06/29 15:04:37]

If to_screen_has_scale_animation is only used for computing animation scale, I
think it should also be moved out of TransformNodeData and into the struct
that's caching animation scale stuff (and if it's used outside of computing
animation scale, then its value shouldn't be changed during the computation of
animation scale).

[sunxd, 2016/06/30 15:29:44]

Done.

+      cached_data_.animation_scales[transform_node_id]
+          .combined_maximum_animation_target_scale = 0.f;
+      cached_data_.animation_scales[transform_node_id]
+          .combined_starting_animation_scale = 0.f;
+    } else if (!node->data.to_screen_has_scale_animation) {
+      cached_data_.animation_scales[transform_node_id]
+          .combined_maximum_animation_target_scale = 0.f;
+      cached_data_.animation_scales[transform_node_id]
+          .combined_starting_animation_scale = 0.f;
+    } else if (node->data.has_only_translation_animations) {
+      gfx::Vector2dF local_scales =
+          MathUtil::ComputeTransform2dScaleComponents(node->data.local, 0.f);
+      float max_local_scale = std::max(local_scales.x(), local_scales.y());
+      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 {
+      LayerImpl* layer_impl = layer_tree_impl->LayerById(node->owner_id);
+      layer_tree_impl->MaximumTargetScale(

[ajuma, 2016/06/29 15:04:37]

Please leave a TODO to make these calls take an id instead of a LayerImpl*.

[sunxd, 2016/06/30 15:29:44]

Done.

+          layer_impl, &cached_data_.animation_scales[transform_node_id]
+                           .local_maximum_animation_target_scale);
+      layer_tree_impl->AnimationStartScale(
+          layer_impl, &cached_data_.animation_scales[transform_node_id]
+                           .local_starting_animation_scale);
+      gfx::Vector2dF local_scales =
+          MathUtil::ComputeTransform2dScaleComponents(node->data.local, 0.f);
+      float max_local_scale = std::max(local_scales.x(), local_scales.y());
+
+      if (cached_data_.animation_scales[transform_node_id]
+                  .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), 0.f)
+                        : gfx::Vector2dF(1.f, 1.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 *
+            cached_data_.animation_scales[transform_node_id]
+                .local_starting_animation_scale;
+      }
+    }
+    cached_data_.animation_scales[transform_node_id].update_number =
+        cached_data_.property_tree_update_number;
+  }
+  return CombinedAnimationScale(cached_data_.animation_scales[transform_node_id]
+                                    .combined_maximum_animation_target_scale,
+                                cached_data_.animation_scales[transform_node_id]
+                                    .combined_starting_animation_scale);
+}
+
+void PropertyTrees::SetAnimationScalesForTesting(
+    int transform_id,
+    float maximum_animation_scale,
+    float starting_animation_scale) {
+  cached_data_.animation_scales[transform_id]
+      .combined_maximum_animation_target_scale = maximum_animation_scale;
+  cached_data_.animation_scales[transform_id]
+      .combined_starting_animation_scale = starting_animation_scale;
+  cached_data_.animation_scales[transform_id].update_number =
+      cached_data_.property_tree_update_number;
+}
+
+void PropertyTrees::ResetCachedData() {
+  cached_data_.property_tree_update_number = 0;
+  cached_data_.animation_scales = std::vector<AnimationScaleData>(
+      transform_tree.nodes().size(), AnimationScaleData());
+}
+
+void PropertyTrees::UpdateCachedNumber() {
+  cached_data_.property_tree_update_number++;
+}
+
 }  // namespace cc