Allow impl-only animations, and return opacity values via AnimationEvents.

cc/layer_animation_controller_unittest.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/layer_animation_controller.h"
 
 #include "cc/animation.h"
 #include "cc/animation_curve.h"
+#include "cc/keyframed_animation_curve.h"
 #include "cc/test/animation_test_common.h"
+#include "cc/transform_operations.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 namespace {
 
 void expectTranslateX(double translateX, const gfx::Transform& matrix)
 {
     EXPECT_FLOAT_EQ(translateX, matrix.matrix().getDouble(0, 3));
@@ skipping 129 matching lines @@
 
     EXPECT_FALSE(controllerImpl->getAnimation(animationId, Animation::Opacity));
 
     controller->pushAnimationUpdatesTo(controllerImpl.get());
 
     // Even though the main thread has a 'new' animation, it should not be pushed because the animation has already completed on the impl thread.
     EXPECT_FALSE(controllerImpl->getAnimation(animationId, Animation::Opacity));
 }
 
 // Tests that transitioning opacity from 0 to 1 works as expected.
+
+static const AnimationEvent* getMostRecentPropertyUpdateEvent(const AnimationEventsVector* events)
+{
+    const AnimationEvent* event = 0;
+    for (size_t i = 0; i < events->size(); ++i)
+        if ((*events)[i].type == AnimationEvent::PropertyUpdate)
+            event = &(*events)[i];
+
+    return event;
+}
+
 TEST(LayerAnimationControllerTest, TrivialTransition)
 {
     scoped_ptr<AnimationEventsVector> events(make_scoped_ptr(new AnimationEventsVector));
     FakeLayerAnimationValueObserver dummy;
     scoped_refptr<LayerAnimationController> controller(LayerAnimationController::create(0));
     controller->addObserver(&dummy);
 
     scoped_ptr<Animation> toAdd(createAnimation(make_scoped_ptr(new FakeFloatTransition(1, 0, 1)).PassAs<AnimationCurve>(), 1, Animation::Opacity));
 
     controller->addAnimation(toAdd.Pass());
     controller->animate(0);
     controller->updateState(events.get());
     EXPECT_TRUE(controller->hasActiveAnimation());
     EXPECT_EQ(0, dummy.opacity());
     controller->animate(1);
     controller->updateState(events.get());
     EXPECT_EQ(1, dummy.opacity());
     EXPECT_FALSE(controller->hasActiveAnimation());
 }
 

[Ian Vollick, 2013/03/06 23:29:45]

I'd also like you to confirm that we don't generate property updates if it's not
an impl only animation. I'd be happy if in one of the existing tests you added a
spot check to make sure that the animation events are sane.

[wjmaclean, 2013/03/07 13:49:29]

We already do that implicitly, in that the checks on events->size() would fail
here if there were any property update events. However, I can easily (and
explicitly) verify there are no property updates in the events just to confirm.

+TEST(LayerAnimationControllerTest, TrivialTransitionOnImpl)
+{
+    scoped_ptr<AnimationEventsVector> events(make_scoped_ptr(new AnimationEventsVector));
+    FakeLayerAnimationValueObserver dummyImpl;
+    scoped_refptr<LayerAnimationController> controllerImpl(LayerAnimationController::create(0));
+    controllerImpl->addObserver(&dummyImpl);
+
+    scoped_ptr<Animation> toAdd(createAnimation(make_scoped_ptr(new FakeFloatTransition(1, 0, 1)).PassAs<AnimationCurve>(), 1, Animation::Opacity));
+    toAdd->setIsImplOnly(true);
+
+    controllerImpl->addAnimation(toAdd.Pass());
+    controllerImpl->animate(0);
+    controllerImpl->updateState(events.get());
+    EXPECT_TRUE(controllerImpl->hasActiveAnimation());
+    EXPECT_EQ(0, dummyImpl.opacity());
+    EXPECT_EQ(2, events->size());
+    const AnimationEvent* startOpacityEvent = getMostRecentPropertyUpdateEvent(events.get());
+    EXPECT_EQ(0, startOpacityEvent->value);
+
+    controllerImpl->animate(1);
+    controllerImpl->updateState(events.get());
+    EXPECT_EQ(1, dummyImpl.opacity());
+    EXPECT_FALSE(controllerImpl->hasActiveAnimation());
+    EXPECT_EQ(4, events->size());
+    const AnimationEvent* endOpacityEvent = getMostRecentPropertyUpdateEvent(events.get());
+    EXPECT_EQ(1, endOpacityEvent->value);
+}
+
+TEST(LayerAnimationControllerTest, TrivialTransformOnImpl)
+{
+    scoped_ptr<AnimationEventsVector> events(make_scoped_ptr(new AnimationEventsVector));
+    FakeLayerAnimationValueObserver dummyImpl;
+    scoped_refptr<LayerAnimationController> controllerImpl(LayerAnimationController::create(0));
+    controllerImpl->addObserver(&dummyImpl);
+
+    // Choose different values for x and y to avoid coincidental values in the
+    // observed transforms.
+    const float deltaX = 3;
+    const float deltaY = 4;
+
+    scoped_ptr<KeyframedTransformAnimationCurve> curve(KeyframedTransformAnimationCurve::create());
+
+    // Create simple Transform animation.
+    TransformOperations operations;
+    curve->addKeyframe(TransformKeyframe::create(0, operations, scoped_ptr<cc::TimingFunction>()));
+    operations.AppendTranslate(deltaX, deltaY, 0);
+    curve->addKeyframe(TransformKeyframe::create(1, operations, scoped_ptr<cc::TimingFunction>()));
+
+    scoped_ptr<Animation> animation(Animation::create(curve.PassAs<AnimationCurve>(), 1, 0, Animation::Transform));
+    animation->setIsImplOnly(true);
+    controllerImpl->addAnimation(animation.Pass());
+
+    // Run animation.
+    controllerImpl->animate(0);
+    controllerImpl->updateState(events.get());
+    EXPECT_TRUE(controllerImpl->hasActiveAnimation());
+    EXPECT_EQ(gfx::Transform(), dummyImpl.transform());
+    EXPECT_EQ(2, events->size());
+    const AnimationEvent* startTransformEvent = getMostRecentPropertyUpdateEvent(events.get());
+    ASSERT_TRUE(startTransformEvent);
+    EXPECT_EQ(gfx::Transform(), startTransformEvent->transform);
+
+    gfx::Transform expectedTransform;
+    expectedTransform.Translate(deltaX, deltaY);
+
+    controllerImpl->animate(1);
+    controllerImpl->updateState(events.get());
+    EXPECT_EQ(expectedTransform, dummyImpl.transform());
+    EXPECT_FALSE(controllerImpl->hasActiveAnimation());
+    EXPECT_EQ(4, events->size());
+    const AnimationEvent* endTransformEvent = getMostRecentPropertyUpdateEvent(events.get());
+    EXPECT_EQ(expectedTransform, endTransformEvent->transform);
+}
+
 // Tests animations that are waiting for a synchronized start time do not finish.
 TEST(LayerAnimationControllerTest, AnimationsWaitingForStartTimeDoNotFinishIfTheyWaitLongerToStartThanTheirDuration)
 {
     scoped_ptr<AnimationEventsVector> events(make_scoped_ptr(new AnimationEventsVector));
     FakeLayerAnimationValueObserver dummy;
     scoped_refptr<LayerAnimationController> controller(LayerAnimationController::create(0));
     controller->addObserver(&dummy);
 
     scoped_ptr<Animation> toAdd(createAnimation(make_scoped_ptr(new FakeFloatTransition(1, 0, 1)).PassAs<AnimationCurve>(), 1, Animation::Opacity));
     toAdd->setNeedsSynchronizedStartTime(true);
@@ skipping 462 matching lines @@
     controller->animate(3);
     controller->updateState(events.get());
 
     // The float tranisition should now be done.
     EXPECT_EQ(1, dummy.opacity());
     EXPECT_FALSE(controller->hasActiveAnimation());
 }
 
 }  // namespace
 }  // namespace cc