cc : Track transform animation changes on transform tree

cc/layers/layer_impl.cc

 // Copyright 2012 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 "cc/layers/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 661 matching lines @@
     // it owns a TransformNode, since this depends on the state of the
     // corresponding Layer at the time of the last commit. For example, if
     // |is_animated| is false, this might mean a transform animation just ticked
     // past its finish point (so the LayerImpl still owns a TransformNode) or it
     // might mean that a transform animation was removed during commit or
     // activation (and, in that case, the LayerImpl will no longer own a
     // TransformNode, unless it has non-animation-related reasons for owning a
     // node).
     if (node->owner_id != id())
       return;
-    if (node->data.is_animated != is_animated) {
-      node->data.is_animated = is_animated;
+    if (node->data.has_potential_animation != is_animated) {
+      node->data.has_potential_animation = is_animated;
       if (is_animated) {
         float maximum_target_scale = 0.f;
         node->data.local_maximum_animation_target_scale =
             MaximumTargetScale(&maximum_target_scale) ? maximum_target_scale
                                                       : 0.f;
 
         float animation_start_scale = 0.f;
         node->data.local_starting_animation_scale =
             AnimationStartScale(&animation_start_scale) ? animation_start_scale
                                                         : 0.f;
@@ skipping 85 matching lines @@
   // layers in the pending tree will find out about these changes as a
   // result of the shared SyncedProperty.
   if (!IsActive())
     return;
 
   SetCurrentScrollOffset(ClampScrollOffsetToLimits(scroll_offset));
 
   layer_tree_impl_->DidAnimateScrollOffset();
 }
 
-void LayerImpl::OnTransformIsPotentiallyAnimatingChanged(bool is_animating) {
-  UpdatePropertyTreeTransformIsAnimated(is_animating);
+void LayerImpl::OnTransformIsCurrentlyAnimatingChanged(
+    bool is_currently_animating) {
+  DCHECK(layer_tree_impl_);
+  TransformTree& transform_tree =
+      layer_tree_impl_->property_trees()->transform_tree;
+  TransformNode* node = transform_tree.Node(transform_tree_index());
+  if (!node)
+    return;
+
+  if (node->owner_id == id())
+    node->data.is_currently_animating = is_currently_animating;
+}
+
+void LayerImpl::OnTransformIsPotentiallyAnimatingChanged(
+    bool has_potential_animation) {
+  UpdatePropertyTreeTransformIsAnimated(has_potential_animation);
   was_ever_ready_since_last_transform_animation_ = false;
 }
 
 void LayerImpl::OnOpacityIsCurrentlyAnimatingChanged(
     bool is_currently_animating) {
   DCHECK(layer_tree_impl_);
   EffectTree& effect_tree = layer_tree_impl_->property_trees()->effect_tree;
   EffectNode* node = effect_tree.Node(effect_tree_index());
 
   if (node->owner_id == id())
@@ skipping 610 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       DrawTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc