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 149 matching lines @@
     : source_node_id(-1),
       sorting_context_id(0),
       needs_local_transform_update(true),
       node_and_ancestors_are_animated_or_invertible(true),
       is_invertible(true),
       ancestors_are_invertible(true),
       has_potential_animation(false),
       is_currently_animating(false),
       to_screen_is_potentially_animated(false),
       has_only_translation_animations(true),
-      to_screen_has_scale_animation(false),
       flattens_inherited_transform(false),
       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 &&
          sorting_context_id == other.sorting_context_id &&
          needs_local_transform_update == other.needs_local_transform_update &&
          node_and_ancestors_are_animated_or_invertible ==
              other.node_and_ancestors_are_animated_or_invertible &&
          is_invertible == other.is_invertible &&
          ancestors_are_invertible == other.ancestors_are_invertible &&
          has_potential_animation == other.has_potential_animation &&
          is_currently_animating == other.is_currently_animating &&
          to_screen_is_potentially_animated ==
              other.to_screen_is_potentially_animated &&
          has_only_translation_animations ==
              other.has_only_translation_animations &&
-         to_screen_has_scale_animation == other.to_screen_has_scale_animation &&
          flattens_inherited_transform == other.flattens_inherited_transform &&
          node_and_ancestors_are_flat == other.node_and_ancestors_are_flat &&
          node_and_ancestors_have_only_integer_translation ==
              other.node_and_ancestors_have_only_integer_translation &&
          scrolls == other.scrolls &&
          needs_sublayer_scale == other.needs_sublayer_scale &&
          affected_by_inner_viewport_bounds_delta_x ==
              other.affected_by_inner_viewport_bounds_delta_x &&
          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 31 matching lines @@
       node_and_ancestors_are_animated_or_invertible);
 
   data->set_is_invertible(is_invertible);
   data->set_ancestors_are_invertible(ancestors_are_invertible);
 
   data->set_has_potential_animation(has_potential_animation);
   data->set_is_currently_animating(is_currently_animating);
   data->set_to_screen_is_potentially_animated(
       to_screen_is_potentially_animated);
   data->set_has_only_translation_animations(has_only_translation_animations);
-  data->set_to_screen_has_scale_animation(to_screen_has_scale_animation);
 
   data->set_flattens_inherited_transform(flattens_inherited_transform);
   data->set_node_and_ancestors_are_flat(node_and_ancestors_are_flat);
 
   data->set_node_and_ancestors_have_only_integer_translation(
       node_and_ancestors_have_only_integer_translation);
   data->set_scrolls(scrolls);
   data->set_needs_sublayer_scale(needs_sublayer_scale);
 
   data->set_affected_by_inner_viewport_bounds_delta_x(
       affected_by_inner_viewport_bounds_delta_x);
   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 13 matching lines @@
   node_and_ancestors_are_animated_or_invertible =
       data.node_and_ancestors_are_animated_or_invertible();
 
   is_invertible = data.is_invertible();
   ancestors_are_invertible = data.ancestors_are_invertible();
 
   has_potential_animation = data.has_potential_animation();
   is_currently_animating = data.is_currently_animating();
   to_screen_is_potentially_animated = data.to_screen_is_potentially_animated();
   has_only_translation_animations = data.has_only_translation_animations();
-  to_screen_has_scale_animation = data.to_screen_has_scale_animation();
 
   flattens_inherited_transform = data.flattens_inherited_transform();
   node_and_ancestors_are_flat = data.node_and_ancestors_are_flat();
 
   node_and_ancestors_have_only_integer_translation =
       data.node_and_ancestors_have_only_integer_translation();
   scrolls = data.scrolls();
   needs_sublayer_scale = data.needs_sublayer_scale();
 
   affected_by_inner_viewport_bounds_delta_x =
       data.affected_by_inner_viewport_bounds_delta_x();
   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 416 matching lines @@
     TransformNode* node = Node(id);
     node->data.transform_changed = false;
   }
 }
 
 void TransformTree::UpdateTransforms(int id) {
   TransformNode* node = Node(id);
   TransformNode* parent_node = parent(node);
   TransformNode* target_node = Node(TargetId(id));
   TransformNode* source_node = Node(node->data.source_node_id);
+  property_trees()->UpdateCachedNumber();
   if (node->data.needs_local_transform_update ||
       NeedsSourceToParentUpdate(node))
     UpdateLocalTransform(node);
   else
     UndoSnapping(node);
   UpdateScreenSpaceTransform(node, parent_node, target_node);
   UpdateSublayerScale(node);
   UpdateTargetSpaceTransform(node, target_node);
   UpdateAnimationProperties(node, parent_node);
   UpdateSnapping(node);
@@ skipping 229 matching lines @@
   gfx::Transform from_target;
   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) {
+  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) {
+    if (!layer_tree_impl->settings()
+             .layer_transforms_should_scale_layer_contents) {
+      cached_data_.animation_scales[transform_node_id].update_number =
+          cached_data_.property_tree_update_number;
+      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;
+      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);
+    }
+
+    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) {
+      CombinedAnimationScale combined_animation_scale =
+          GetAnimationScales(parent_node->id, layer_tree_impl);
+      ancestor_maximum_target_scale =
+          combined_animation_scale.maximum_animation_scale;
+      ancestor_starting_animation_scale =
+          combined_animation_scale.starting_animation_scale;
+      ancestor_is_animating_scale =
+          cached_data_.animation_scales[parent_node->id]
+              .to_screen_has_scale_animation;
+    }
+
+    cached_data_.animation_scales[transform_node_id]
+        .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 =
+        !transform_tree.ToTarget(transform_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) {
+      // This ensures that descendants know we've failed to compute a maximum
+      // animated scale.
+      cached_data_.animation_scales[transform_node_id]
+          .to_screen_has_scale_animation = true;
+
+      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 (!cached_data_.animation_scales[transform_node_id]
+                    .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) {
+      // 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());
+      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 {
+      // TODO(sunxd): make LayerTreeImpl::MaximumTargetScale take layer id as
+      // parameter.
+      LayerImpl* layer_impl = layer_tree_impl->LayerById(node->owner_id);
+      layer_tree_impl->MaximumTargetScale(
+          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