Transform animations should not collapse by default when interpolating

cc/animation/element_animations.cc

 // Copyright 2015 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/animation/element_animations.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_player.h"
 #include "cc/animation/keyframed_animation_curve.h"
+#include "cc/animation/transform_operations.h"
 #include "cc/base/filter_operations.h"
 #include "cc/trees/mutator_host_client.h"
 #include "ui/gfx/geometry/box_f.h"
 
 namespace cc {
 
 scoped_refptr<ElementAnimations> ElementAnimations::Create() {
   return make_scoped_refptr(new ElementAnimations());
 }
 
@@ skipping 165 matching lines @@
 
   UpdateClientAnimationState();
 }
 
 void ElementAnimations::NotifyAnimationPropertyUpdate(
     const AnimationEvent& event) {
   DCHECK(!event.is_impl_only);
   bool notify_active_elements = true;
   bool notify_pending_elements = true;
   switch (event.target_property) {
-    case TargetProperty::OPACITY:
+    case TargetProperty::OPACITY: {
       NotifyClientOpacityAnimated(event.opacity, notify_active_elements,
                                   notify_pending_elements);
       break;
-    case TargetProperty::TRANSFORM:
-      NotifyClientTransformAnimated(event.transform, notify_active_elements,
-                                    notify_pending_elements);
+    }
+    case TargetProperty::TRANSFORM: {
+      TransformOperations operations;
+      operations.AppendMatrix(event.transform);
+      NotifyClientTransformOperationsAnimated(
+          operations, notify_active_elements, notify_pending_elements);
       break;
+    }
     default:
       NOTREACHED();
   }
 }
 
 bool ElementAnimations::HasFilterAnimationThatInflatesBounds() const {
   for (auto& player : players_list_) {
     if (player.HasFilterAnimationThatInflatesBounds())
       return true;
   }
@@ skipping 96 matching lines @@
 void ElementAnimations::NotifyClientOpacityAnimated(
     float opacity,
     bool notify_active_elements,
     bool notify_pending_elements) {
   if (notify_active_elements && has_element_in_active_list())
     OnOpacityAnimated(ElementListType::ACTIVE, opacity);
   if (notify_pending_elements && has_element_in_pending_list())
     OnOpacityAnimated(ElementListType::PENDING, opacity);
 }
 
-void ElementAnimations::NotifyClientTransformAnimated(
-    const gfx::Transform& transform,
+void ElementAnimations::NotifyClientTransformOperationsAnimated(
+    const TransformOperations& operations,
     bool notify_active_elements,
     bool notify_pending_elements) {
+  gfx::Transform transform = operations.Apply();
   if (notify_active_elements && has_element_in_active_list())
     OnTransformAnimated(ElementListType::ACTIVE, transform);
   if (notify_pending_elements && has_element_in_pending_list())
     OnTransformAnimated(ElementListType::PENDING, transform);
 }
 
 void ElementAnimations::NotifyClientFilterAnimated(
     const FilterOperations& filters,
     bool notify_active_elements,
     bool notify_pending_elements) {
@@ skipping 156 matching lines @@
   if (animation_host()) {
     DCHECK(animation_host()->mutator_host_client());
     return animation_host()->mutator_host_client()->GetScrollOffsetForAnimation(
         element_id());
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc