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/test/animation_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 49 matching lines @@
 
     controller->pushAnimationUpdatesTo(controllerImpl.get());
 
     EXPECT_TRUE(controllerImpl->getAnimation(0, Animation::Opacity));
     EXPECT_EQ(Animation::WaitingForTargetAvailability, controllerImpl->getAnimation(0, Animation::Opacity)->runState());
 
     AnimationEventsVector events;
     controllerImpl->animate(1);
     controllerImpl->updateState(&events);
 
-    // Synchronize the start times.
-    EXPECT_EQ(1u, events.size());
+    // Synchronize the start times. This will also have a property update
+    // event for opacity.
+    EXPECT_EQ(2u, events.size());
     controller->OnAnimationStarted(events[0]);
     EXPECT_EQ(controller->getAnimation(0, Animation::Opacity)->startTime(), controllerImpl->getAnimation(0, Animation::Opacity)->startTime());
 
     // Start the animation on the main thread. Should not affect the start time.
     controller->animate(1.5);
     controller->updateState(0);
     EXPECT_EQ(controller->getAnimation(0, Animation::Opacity)->startTime(), controllerImpl->getAnimation(0, Animation::Opacity)->startTime());
 }
 
 TEST(LayerAnimationControllerTest, syncPauseAndResume)
@@ skipping 67 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* getLastPropertyUpdateOpacityEvent(const AnimationEventsVector* events)
+{
+    const AnimationEvent* event = 0;
+    for (size_t i = 0; i < events->size(); ++i)
+        if ((*events)[i].type == AnimationEvent::PropertyUpdate &&
+            (*events)[i].targetProperty == Animation::Opacity)
+            event = &(*events)[i];
+
+    return event;
+}
+

[Ian Vollick, 2013/03/06 01:00:57]

I would like 3 new tests rather than these tweaks on the old tests:
1) Ensure that animations with a main thread counterpart do not issue property
update events.
2) Ensure that impl-only opacity animations send back property update events
with the correct value.
3) Same as 2), but for transform animations.

[wjmaclean, 2013/03/06 17:03:13]

Now that non implOnly animations do not send back property updates, can the
existing test cover this? (once I restore the checks on the size of the events
queue to their original size ...)
Done.

 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());
+    EXPECT_EQ(2, events->size());
+    const AnimationEvent* startOpacityEvent = getLastPropertyUpdateOpacityEvent(events.get());
+    ASSERT_TRUE(startOpacityEvent);
+    EXPECT_EQ(0, startOpacityEvent->value);
     controller->animate(1);
     controller->updateState(events.get());
     EXPECT_EQ(1, dummy.opacity());
     EXPECT_FALSE(controller->hasActiveAnimation());
+    EXPECT_EQ(4, events->size());
+    const AnimationEvent* endOpacityEvent = getLastPropertyUpdateOpacityEvent(events.get());
+    ASSERT_TRUE(endOpacityEvent);
+    EXPECT_EQ(1, endOpacityEvent->value);
 }
 
 // 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);
 
@@ skipping 446 matching lines @@
 
     controller->addAnimation(createAnimation(make_scoped_ptr(new FakeFloatTransition(1, 0, 1)).PassAs<AnimationCurve>(), 2, Animation::Opacity));
 
     // Animate but don't updateState.
     controller->animate(1);
 
     controller->animate(2);
     events.reset(new AnimationEventsVector);
     controller->updateState(events.get());
 
-    // Should have one Started event and one Finished event.
-    EXPECT_EQ(2, events->size());
+    // Should have one Started event, one Finished event, and one
+    // opacity property update event.
+    EXPECT_EQ(3, events->size());
     EXPECT_NE((*events)[0].type, (*events)[1].type);
+    EXPECT_NE((*events)[0].type, (*events)[2].type);
+    EXPECT_NE((*events)[1].type, (*events)[2].type);
 
     // The float transition should still be at its starting point.
     EXPECT_TRUE(controller->hasActiveAnimation());
     EXPECT_EQ(0, dummy.opacity());
 
     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