cc : Add OnTransformAnimated to transform tree

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 200 matching lines @@
         return false;
       transform->ConcatTransform(from_screen);
     }
   }
 
   DCHECK(
       transform->IsApproximatelyIdentityOrTranslation(SkDoubleToMScalar(1e-4)));
   return true;
 }
 
+void TransformTree::OnTransformAnimated(const gfx::Transform& transform,
+                                        int id,
+                                        LayerTreeImpl* layer_tree_impl) {
+  TransformNode* node = Node(id);
+  layer_tree_impl->AddToTransformAnimationsMap(node->owner_id, transform);
+  if (node->local == transform) {
+    return;
+  }
+  node->local = transform;
+  node->needs_local_transform_update = true;
+  node->transform_changed = true;
+  property_trees()->changed = true;
+  set_needs_update(true);
+  layer_tree_impl->set_needs_update_draw_properties();
+  // TODO(ajuma): The current criteria for creating clip nodes means that
+  // property trees may need to be rebuilt when the new transform isn't
+  // axis-aligned wrt the old transform (see Layer::SetTransform). Since
+  // rebuilding property trees every frame of a transform animation is
+  // something we should try to avoid, change property tree-building so that
+  // it doesn't depend on axis aliginment.

[ajuma, 2016/08/23 23:40:12]

I think this TODO is obsolete now, since we don't check axis-alignment when
creating clip nodes.

[jaydasika, 2016/08/24 00:13:42]

Removed!

+}
+
 bool TransformTree::NeedsSourceToParentUpdate(TransformNode* node) {
   return (source_to_parent_updates_allowed() &&
           node->parent_id != node->source_node_id);
 }
 
 void TransformTree::ResetChangeTracking() {
   for (int id = 1; id < static_cast<int>(size()); ++id) {
     TransformNode* node = Node(id);
     node->transform_changed = false;
   }
@@ skipping 679 matching lines @@
     layer_scale_factor *= transform_tree.page_scale_factor();
   effect_node->surface_contents_scale =
       MathUtil::ComputeTransform2dScaleComponents(
           transform_tree.ToScreen(transform_node->id), layer_scale_factor);
 }
 
 void EffectTree::OnOpacityAnimated(float opacity,
                                    int id,
                                    LayerTreeImpl* layer_tree_impl) {
   EffectNode* node = Node(id);
+  layer_tree_impl->AddToOpacityAnimationsMap(node->owner_id, opacity);
   if (node->opacity == opacity)
     return;
   node->opacity = opacity;
   node->effect_changed = true;
   property_trees()->changed = true;
   property_trees()->effect_tree.set_needs_update(true);
   layer_tree_impl->set_needs_update_draw_properties();
-  layer_tree_impl->AddToOpacityAnimationsMap(node->owner_id, opacity);
 }
 
 void EffectTree::UpdateEffects(int id) {
   EffectNode* node = Node(id);
   EffectNode* parent_node = parent(node);
 
   UpdateOpacities(node, parent_node);
   UpdateIsDrawn(node, parent_node);
   UpdateEffectChanged(node, parent_node);
   UpdateBackfaceVisibility(node, parent_node);
@@ skipping 1265 matching lines @@
     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);
   }
   return success;
 }
 
 }  // namespace cc