cc : Track transform animation changes on transform tree

cc/layers/layer.cc

 // Copyright 2010 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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1610 matching lines @@
   // Changing the transform may change the visible part of this layer, so a new
   // recording may be needed.
   SetNeedsUpdate();
   if (layer_tree_host_) {
     if (TransformNode* node =
             layer_tree_host_->property_trees()->transform_tree.Node(
                 transform_tree_index())) {
       if (node->owner_id == id()) {
         node->data.local = transform;
         node->data.needs_local_transform_update = true;
-        node->data.is_animated = true;
+        node->data.has_potential_animation = true;
         layer_tree_host_->property_trees()->transform_tree.set_needs_update(
             true);
       }
     }
   }
 }
 
 void Layer::OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset) {
   // Do nothing. Scroll deltas will be sent from the compositor thread back
   // to the main thread in the same manner as during non-animated
   // compositor-driven scrolling.
 }
 
-void Layer::OnTransformIsPotentiallyAnimatingChanged(bool is_animating) {
+void Layer::OnTransformIsCurrentlyAnimatingChanged(
+    bool is_currently_animating) {
+  DCHECK(layer_tree_host_);
+  TransformTree& transform_tree =
+      layer_tree_host_->property_trees()->transform_tree;
+  TransformNode* node = transform_tree.Node(transform_tree_index());
+  if (!node)
+    return;
+
+  if (node->owner_id == id())

[jaydasika, 2016/05/18 00:57:23]

I will make this use the map in a follow up. My plan is to rename
PropertyTrees::ResetFlags(which is no longer used) to something like
PropertyTrees::Property and have a
PropertyTrees::IsInIdToIndexMap(PropertyTrees::Property, id) and use that here
and elsewhere.

+    node->data.is_currently_animating = is_currently_animating;
+}
+
+void Layer::OnTransformIsPotentiallyAnimatingChanged(
+    bool has_potential_animation) {
   if (!layer_tree_host_)
     return;
   TransformTree& transform_tree =
       layer_tree_host_->property_trees()->transform_tree;
   TransformNode* node = transform_tree.Node(transform_tree_index());
   if (!node)
     return;
 
   if (node->owner_id == id()) {
-    node->data.is_animated = is_animating;
-    if (is_animating) {
+    node->data.has_potential_animation = has_potential_animation;
+    if (has_potential_animation) {
       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 119 matching lines @@
       ->data.num_copy_requests_in_subtree;
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc