cc/CCLayerAnimationControllerTest.cpp

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "config.h"
   6
   7 #include "CCLayerAnimationController.h"
   8
   9 #include "CCActiveAnimation.h"
  10 #include "CCAnimationCurve.h"
  11 #include "CCAnimationTestCommon.h"
  12 #include <gmock/gmock.h>
  13 #include <gtest/gtest.h>
  14 #include <public/WebTransformationMatrix.h>
  15 #include <wtf/Vector.h>
  16
  17 using namespace WebCore;
  18 using namespace WebKitTests;
  19 using WebKit::WebTransformationMatrix;
  20
  21 namespace {
  22
  23 void expectTranslateX(double translateX, const WebTransformationMatrix& matrix)
  24 {
  25     EXPECT_FLOAT_EQ(translateX, matrix.m41());
  26 }
  27
  28 PassOwnPtr<CCActiveAnimation> createActiveAnimation(PassOwnPtr<CCAnimationCurve> curve, int id, CCActiveAnimation::TargetProperty property)
  29 {
  30     return CCActiveAnimation::create(curve, 0, id, property);
  31 }
  32
  33 TEST(CCLayerAnimationControllerTest, syncNewAnimation)
  34 {
  35     FakeLayerAnimationControllerClient dummyImpl;
  36     OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController::create(&dummyImpl));
  37     FakeLayerAnimationControllerClient dummy;
  38     OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create(&dummy));
  39
  40     EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
  41
  42     addOpacityTransitionToController(*controller, 1, 0, 1, false);
  43
  44     controller->pushAnimationUpdatesTo(controllerImpl.get());
  45
  46     EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
  47     EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
  48 }
  49
  50 // If an animation is started on the impl thread before it is ticked on the main
  51 // thread, we must be sure to respect the synchronized start time.
  52 TEST(CCLayerAnimationControllerTest, doNotClobberStartTimes)
  53 {
  54     FakeLayerAnimationControllerClient dummyImpl;
  55     OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController::create(&dummyImpl));
  56     FakeLayerAnimationControllerClient dummy;
  57     OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create(&dummy));
  58
  59     EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
  60
  61     addOpacityTransitionToController(*controller, 1, 0, 1, false);
  62
  63     controller->pushAnimationUpdatesTo(controllerImpl.get());
  64
  65     EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
  66     EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
  67
  68     CCAnimationEventsVector events;
  69     controllerImpl->animate(1, &events);
  70
  71     // Synchronize the start times.
  72     EXPECT_EQ(1u, events.size());
  73     controller->notifyAnimationStarted(events[0]);
  74     EXPECT_EQ(controller->getActiveAnimation(0, CCActiveAnimation::Opacity)->startTime(), controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->startTime());
  75
  76     // Start the animation on the main thread. Should not affect the start time.
  77     controller->animate(1.5, 0);
  78     EXPECT_EQ(controller->getActiveAnimation(0, CCActiveAnimation::Opacity)->startTime(), controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->startTime());
  79 }
  80
  81 TEST(CCLayerAnimationControllerTest, syncPauseAndResume)
  82 {
  83     FakeLayerAnimationControllerClient dummyImpl;
  84     OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController::create(&dummyImpl));
  85     FakeLayerAnimationControllerClient dummy;
  86     OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create(&dummy));
  87
  88     EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
  89
  90     addOpacityTransitionToController(*controller, 1, 0, 1, false);
  91
  92     controller->pushAnimationUpdatesTo(controllerImpl.get());
  93
  94     EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
  95     EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
  96
  97     // Start the animations on each controller.
  98     CCAnimationEventsVector events;
  99     controllerImpl->animate(0, &events);
 100     controller->animate(0, 0);
 101     EXPECT_EQ(CCActiveAnimation::Running, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
 102     EXPECT_EQ(CCActiveAnimation::Running, controller->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
 103
 104     // Pause the main-thread animation.
 105     controller->suspendAnimations(1);
 106     EXPECT_EQ(CCActiveAnimation::Paused, controller->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
 107
 108     // The pause run state change should make it to the impl thread controller.
 109     controller->pushAnimationUpdatesTo(controllerImpl.get());
 110     EXPECT_EQ(CCActiveAnimation::Paused, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
 111
 112     // Resume the main-thread animation.
 113     controller->resumeAnimations(2);
 114     EXPECT_EQ(CCActiveAnimation::Running, controller->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
 115
 116     // The pause run state change should make it to the impl thread controller.
 117     controller->pushAnimationUpdatesTo(controllerImpl.get());
 118     EXPECT_EQ(CCActiveAnimation::Running, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
 119 }
 120
 121 TEST(CCLayerAnimationControllerTest, doNotSyncFinishedAnimation)
 122 {
 123     FakeLayerAnimationControllerClient dummyImpl;
 124     OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController::create(&dummyImpl));
 125     FakeLayerAnimationControllerClient dummy;
 126     OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create(&dummy));
 127
 128     EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
 129
 130     addOpacityTransitionToController(*controller, 1, 0, 1, false);
 131
 132     controller->pushAnimationUpdatesTo(controllerImpl.get());
 133
 134     EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
 135     EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
 136
 137     // Notify main thread controller that the animation has started.
 138     CCAnimationEvent animationStartedEvent(CCAnimationEvent::Started, 0, 0, CCActiveAnimation::Opacity, 0);
 139     controller->notifyAnimationStarted(animationStartedEvent);
 140
 141     // Force animation to complete on impl thread.
 142     controllerImpl->removeAnimation(0);
 143
 144     EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
 145
 146     controller->pushAnimationUpdatesTo(controllerImpl.get());
 147
 148     // Even though the main thread has a 'new' animation, it should not be pushed because the animation has already completed on the impl thread.
 149     EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
 150 }
 151
 152 // Tests that transitioning opacity from 0 to 1 works as expected.
 153 TEST(CCLayerAnimationControllerTest, TrivialTransition)
 154 {
 155     OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
 156     FakeLayerAnimationControllerClient dummy;
 157     OwnPtr<CCLayerAnimationController> controller(
 158         CCLayerAnimationController::create(&dummy));
 159
 160     OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity));
 161
 162     controller->addAnimation(toAdd.release());
 163     controller->animate(0, events.get());
 164     EXPECT_TRUE(controller->hasActiveAnimation());
 165     EXPECT_EQ(0, dummy.opacity());
 166     controller->animate(1, events.get());
 167     EXPECT_EQ(1, dummy.opacity());
 168     EXPECT_FALSE(controller->hasActiveAnimation());
 169 }
 170
 171 // Tests animations that are waiting for a synchronized start time do not finish.
 172 TEST(CCLayerAnimationControllerTest, AnimationsWaitingForStartTimeDoNotFinishIfTheyWaitLongerToStartThanTheirDuration)
 173 {
 174     OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
 175     FakeLayerAnimationControllerClient dummy;
 176     OwnPtr<CCLayerAnimationController> controller(
 177         CCLayerAnimationController::create(&dummy));
 178
 179     OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity));
 180     toAdd->setNeedsSynchronizedStartTime(true);
 181
 182     // We should pause at the first keyframe indefinitely waiting for that animation to start.
 183     controller->addAnimation(toAdd.release());
 184     controller->animate(0, events.get());
 185     EXPECT_TRUE(controller->hasActiveAnimation());
 186     EXPECT_EQ(0, dummy.opacity());
 187     controller->animate(1, events.get());
 188     EXPECT_TRUE(controller->hasActiveAnimation());
 189     EXPECT_EQ(0, dummy.opacity());
 190     controller->animate(2, events.get());
 191     EXPECT_TRUE(controller->hasActiveAnimation());
 192     EXPECT_EQ(0, dummy.opacity());
 193
 194     // Send the synchronized start time.
 195     controller->notifyAnimationStarted(CCAnimationEvent(CCAnimationEvent::Started, 0, 1, CCActiveAnimation::Opacity, 2));
 196     controller->animate(5, events.get());
 197     EXPECT_EQ(1, dummy.opacity());
 198     EXPECT_FALSE(controller->hasActiveAnimation());
 199 }
 200
 201 // Tests that two queued animations affecting the same property run in sequence.
 202 TEST(CCLayerAnimationControllerTest, TrivialQueuing)
 203 {
 204     OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
 205     FakeLayerAnimationControllerClient dummy;
 206     OwnPtr<CCLayerAnimationController> controller(
 207         CCLayerAnimationController::create(&dummy));
 208
 209     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity));
 210     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 1, 0.5)), 2, CCActiveAnimation::Opacity));
 211
 212     controller->animate(0, events.get());
 213     EXPECT_TRUE(controller->hasActiveAnimation());
 214     EXPECT_EQ(0, dummy.opacity());
 215     controller->animate(1, events.get());
 216     EXPECT_TRUE(controller->hasActiveAnimation());
 217     EXPECT_EQ(1, dummy.opacity());
 218     controller->animate(2, events.get());
 219     EXPECT_EQ(0.5, dummy.opacity());
 220     EXPECT_FALSE(controller->hasActiveAnimation());
 221 }
 222
 223 // Tests interrupting a transition with another transition.
 224 TEST(CCLayerAnimationControllerTest, Interrupt)
 225 {
 226     OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
 227     FakeLayerAnimationControllerClient dummy;
 228     OwnPtr<CCLayerAnimationController> controller(
 229         CCLayerAnimationController::create(&dummy));
 230     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity));
 231     controller->animate(0, events.get());
 232     EXPECT_TRUE(controller->hasActiveAnimation());
 233     EXPECT_EQ(0, dummy.opacity());
 234
 235     OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 1, 0.5)), 2, CCActiveAnimation::Opacity));
 236     toAdd->setRunState(CCActiveAnimation::WaitingForNextTick, 0);
 237     controller->addAnimation(toAdd.release());
 238
 239     // Since the animation was in the WaitingForNextTick state, it should start right in
 240     // this call to animate.
 241     controller->animate(0.5, events.get());
 242     EXPECT_TRUE(controller->hasActiveAnimation());
 243     EXPECT_EQ(1, dummy.opacity());
 244     controller->animate(1.5, events.get());
 245     EXPECT_EQ(0.5, dummy.opacity());
 246     EXPECT_FALSE(controller->hasActiveAnimation());
 247 }
 248
 249 // Tests scheduling two animations to run together when only one property is free.
 250 TEST(CCLayerAnimationControllerTest, ScheduleTogetherWhenAPropertyIsBlocked)
 251 {
 252     OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
 253     FakeLayerAnimationControllerClient dummy;
 254     OwnPtr<CCLayerAnimationController> controller(
 255         CCLayerAnimationController::create(&dummy));
 256
 257     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeTransformTransition(1)), 1, CCActiveAnimation::Transform));
 258     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeTransformTransition(1)), 2, CCActiveAnimation::Transform));
 259     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 2, CCActiveAnimation::Opacity));
 260
 261     controller->animate(0, events.get());
 262     EXPECT_EQ(0, dummy.opacity());
 263     EXPECT_TRUE(controller->hasActiveAnimation());
 264     controller->animate(1, events.get());
 265     // Should not have started the float transition yet.
 266     EXPECT_TRUE(controller->hasActiveAnimation());
 267     EXPECT_EQ(0, dummy.opacity());
 268     // The float animation should have started at time 1 and should be done.
 269     controller->animate(2, events.get());
 270     EXPECT_EQ(1, dummy.opacity());
 271     EXPECT_FALSE(controller->hasActiveAnimation());
 272 }
 273
 274 // Tests scheduling two animations to run together with different lengths and another
 275 // animation queued to start when the shorter animation finishes (should wait
 276 // for both to finish).
 277 TEST(CCLayerAnimationControllerTest, ScheduleTogetherWithAnAnimWaiting)
 278 {
 279     OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
 280     FakeLayerAnimationControllerClient dummy;
 281     OwnPtr<CCLayerAnimationController> controller(
 282         CCLayerAnimationController::create(&dummy));
 283
 284     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeTransformTransition(2)), 1, CCActiveAnimation::Transform));
 285     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity));
 286     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 1, 0.5)), 2, CCActiveAnimation::Opacity));
 287
 288     // Animations with id 1 should both start now.
 289     controller->animate(0, events.get());
 290     EXPECT_TRUE(controller->hasActiveAnimation());
 291     EXPECT_EQ(0, dummy.opacity());
 292     // The opacity animation should have finished at time 1, but the group
 293     // of animations with id 1 don't finish until time 2 because of the length
 294     // of the transform animation.
 295     controller->animate(2, events.get());
 296     // Should not have started the float transition yet.
 297     EXPECT_TRUE(controller->hasActiveAnimation());
 298     EXPECT_EQ(1, dummy.opacity());
 299
 300     // The second opacity animation should start at time 2 and should be done by time 3
 301     controller->animate(3, events.get());
 302     EXPECT_EQ(0.5, dummy.opacity());
 303     EXPECT_FALSE(controller->hasActiveAnimation());
 304 }
 305
 306 // Tests scheduling an animation to start in the future.
 307 TEST(CCLayerAnimationControllerTest, ScheduleAnimation)
 308 {
 309     OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
 310     FakeLayerAnimationControllerClient dummy;
 311     OwnPtr<CCLayerAnimationController> controller(
 312         CCLayerAnimationController::create(&dummy));
 313
 314     OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity));
 315     toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0);
 316     toAdd->setStartTime(1);
 317     controller->addAnimation(toAdd.release());
 318
 319     controller->animate(0, events.get());
 320     EXPECT_TRUE(controller->hasActiveAnimation());
 321     EXPECT_EQ(0, dummy.opacity());
 322     controller->animate(1, events.get());
 323     EXPECT_TRUE(controller->hasActiveAnimation());
 324     EXPECT_EQ(0, dummy.opacity());
 325     controller->animate(2, events.get());
 326     EXPECT_EQ(1, dummy.opacity());
 327     EXPECT_FALSE(controller->hasActiveAnimation());
 328 }
 329
 330 // Tests scheduling an animation to start in the future that's interrupting a running animation.
 331 TEST(CCLayerAnimationControllerTest, ScheduledAnimationInterruptsRunningAnimation)
 332 {
 333     OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
 334     FakeLayerAnimationControllerClient dummy;
 335     OwnPtr<CCLayerAnimationController> controller(
 336         CCLayerAnimationController::create(&dummy));
 337
 338     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransition(2, 0, 1)), 1, CCActiveAnimation::Opacity));
 339
 340     OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0.5, 0)), 2, CCActiveAnimation::Opacity));
 341     toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0);
 342     toAdd->setStartTime(1);
 343     controller->addAnimation(toAdd.release());
 344
 345     // First 2s opacity transition should start immediately.
 346     controller->animate(0, events.get());
 347     EXPECT_TRUE(controller->hasActiveAnimation());
 348     EXPECT_EQ(0, dummy.opacity());
 349     controller->animate(0.5, events.get());
 350     EXPECT_TRUE(controller->hasActiveAnimation());
 351     EXPECT_EQ(0.25, dummy.opacity());
 352     controller->animate(1, events.get());
 353     EXPECT_TRUE(controller->hasActiveAnimation());
 354     EXPECT_EQ(0.5, dummy.opacity());
 355     controller->animate(2, events.get());
 356     EXPECT_EQ(0, dummy.opacity());
 357     EXPECT_FALSE(controller->hasActiveAnimation());
 358 }
 359
 360 // Tests scheduling an animation to start in the future that interrupts a running animation
 361 // and there is yet another animation queued to start later.
 362 TEST(CCLayerAnimationControllerTest, ScheduledAnimationInterruptsRunningAnimationWithAnimInQueue)
 363 {
 364     OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
 365     FakeLayerAnimationControllerClient dummy;
 366     OwnPtr<CCLayerAnimationController> controller(
 367         CCLayerAnimationController::create(&dummy));
 368
 369     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransition(2, 0, 1)), 1, CCActiveAnimation::Opacity));
 370
 371     OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(2, 0.5, 0)), 2, CCActiveAnimation::Opacity));
 372     toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0);
 373     toAdd->setStartTime(1);
 374     controller->addAnimation(toAdd.release());
 375
 376     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 0.75)), 3, CCActiveAnimation::Opacity));
 377
 378     // First 2s opacity transition should start immediately.
 379     controller->animate(0, events.get());
 380     EXPECT_TRUE(controller->hasActiveAnimation());
 381     EXPECT_EQ(0, dummy.opacity());
 382     controller->animate(0.5, events.get());
 383     EXPECT_TRUE(controller->hasActiveAnimation());
 384     EXPECT_EQ(0.25, dummy.opacity());
 385     EXPECT_TRUE(controller->hasActiveAnimation());
 386     controller->animate(1, events.get());
 387     EXPECT_TRUE(controller->hasActiveAnimation());
 388     EXPECT_EQ(0.5, dummy.opacity());
 389     controller->animate(3, events.get());
 390     EXPECT_TRUE(controller->hasActiveAnimation());
 391     EXPECT_EQ(0, dummy.opacity());
 392     controller->animate(4, events.get());
 393     EXPECT_EQ(0.75, dummy.opacity());
 394     EXPECT_FALSE(controller->hasActiveAnimation());
 395 }
 396
 397 // Test that a looping animation loops and for the correct number of iterations.
 398 TEST(CCLayerAnimationControllerTest, TrivialLooping)
 399 {
 400     OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
 401     FakeLayerAnimationControllerClient dummy;
 402     OwnPtr<CCLayerAnimationController> controller(
 403         CCLayerAnimationController::create(&dummy));
 404
 405     OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity));
 406     toAdd->setIterations(3);
 407     controller->addAnimation(toAdd.release());
 408
 409     controller->animate(0, events.get());
 410     EXPECT_TRUE(controller->hasActiveAnimation());
 411     EXPECT_EQ(0, dummy.opacity());
 412     controller->animate(1.25, events.get());
 413     EXPECT_TRUE(controller->hasActiveAnimation());
 414     EXPECT_EQ(0.25, dummy.opacity());
 415     controller->animate(1.75, events.get());
 416     EXPECT_TRUE(controller->hasActiveAnimation());
 417     EXPECT_EQ(0.75, dummy.opacity());
 418     controller->animate(2.25, events.get());
 419     EXPECT_TRUE(controller->hasActiveAnimation());
 420     EXPECT_EQ(0.25, dummy.opacity());
 421     controller->animate(2.75, events.get());
 422     EXPECT_TRUE(controller->hasActiveAnimation());
 423     EXPECT_EQ(0.75, dummy.opacity());
 424     controller->animate(3, events.get());
 425     EXPECT_FALSE(controller->hasActiveAnimation());
 426     EXPECT_EQ(1, dummy.opacity());
 427
 428     // Just be extra sure.
 429     controller->animate(4, events.get());
 430     EXPECT_EQ(1, dummy.opacity());
 431 }
 432
 433 // Test that an infinitely looping animation does indeed go until aborted.
 434 TEST(CCLayerAnimationControllerTest, InfiniteLooping)
 435 {
 436     OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
 437     FakeLayerAnimationControllerClient dummy;
 438     OwnPtr<CCLayerAnimationController> controller(
 439         CCLayerAnimationController::create(&dummy));
 440
 441     const int id = 1;
 442     OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), id, CCActiveAnimation::Opacity));
 443     toAdd->setIterations(-1);
 444     controller->addAnimation(toAdd.release());
 445
 446     controller->animate(0, events.get());
 447     EXPECT_TRUE(controller->hasActiveAnimation());
 448     EXPECT_EQ(0, dummy.opacity());
 449     controller->animate(1.25, events.get());
 450     EXPECT_TRUE(controller->hasActiveAnimation());
 451     EXPECT_EQ(0.25, dummy.opacity());
 452     controller->animate(1.75, events.get());
 453     EXPECT_TRUE(controller->hasActiveAnimation());
 454     EXPECT_EQ(0.75, dummy.opacity());
 455
 456     controller->animate(1073741824.25, events.get());
 457     EXPECT_TRUE(controller->hasActiveAnimation());
 458     EXPECT_EQ(0.25, dummy.opacity());
 459     controller->animate(1073741824.75, events.get());
 460     EXPECT_TRUE(controller->hasActiveAnimation());
 461     EXPECT_EQ(0.75, dummy.opacity());
 462
 463     EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity));
 464     controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(CCActiveAnimation::Aborted, 0.75);
 465     EXPECT_FALSE(controller->hasActiveAnimation());
 466     EXPECT_EQ(0.75, dummy.opacity());
 467 }
 468
 469 // Test that pausing and resuming work as expected.
 470 TEST(CCLayerAnimationControllerTest, PauseResume)
 471 {
 472     OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
 473     FakeLayerAnimationControllerClient dummy;
 474     OwnPtr<CCLayerAnimationController> controller(
 475         CCLayerAnimationController::create(&dummy));
 476
 477     const int id = 1;
 478     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), id, CCActiveAnimation::Opacity));
 479
 480     controller->animate(0, events.get());
 481     EXPECT_TRUE(controller->hasActiveAnimation());
 482     EXPECT_EQ(0, dummy.opacity());
 483     controller->animate(0.5, events.get());
 484     EXPECT_TRUE(controller->hasActiveAnimation());
 485     EXPECT_EQ(0.5, dummy.opacity());
 486
 487     EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity));
 488     controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(CCActiveAnimation::Paused, 0.5);
 489
 490     controller->animate(1024, events.get());
 491     EXPECT_TRUE(controller->hasActiveAnimation());
 492     EXPECT_EQ(0.5, dummy.opacity());
 493
 494     EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity));
 495     controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(CCActiveAnimation::Running, 1024);
 496
 497     controller->animate(1024.25, events.get());
 498     EXPECT_TRUE(controller->hasActiveAnimation());
 499     EXPECT_EQ(0.75, dummy.opacity());
 500     controller->animate(1024.5, events.get());
 501     EXPECT_FALSE(controller->hasActiveAnimation());
 502     EXPECT_EQ(1, dummy.opacity());
 503 }
 504
 505 TEST(CCLayerAnimationControllerTest, AbortAGroupedAnimation)
 506 {
 507     OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
 508     FakeLayerAnimationControllerClient dummy;
 509     OwnPtr<CCLayerAnimationController> controller(
 510         CCLayerAnimationController::create(&dummy));
 511
 512     const int id = 1;
 513     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeTransformTransition(1)), id, CCActiveAnimation::Transform));
 514     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransition(2, 0, 1)), id, CCActiveAnimation::Opacity));
 515     controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 1, 0.75)), 2, CCActiveAnimation::Opacity));
 516
 517     controller->animate(0, events.get());
 518     EXPECT_TRUE(controller->hasActiveAnimation());
 519     EXPECT_EQ(0, dummy.opacity());
 520     controller->animate(1, events.get());
 521     EXPECT_TRUE(controller->hasActiveAnimation());
 522     EXPECT_EQ(0.5, dummy.opacity());
 523
 524     EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity));
 525     controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(CCActiveAnimation::Aborted, 1);
 526     controller->animate(1, events.get());
 527     EXPECT_TRUE(controller->hasActiveAnimation());
 528     EXPECT_EQ(1, dummy.opacity());
 529     controller->animate(2, events.get());
 530     EXPECT_TRUE(!controller->hasActiveAnimation());
 531     EXPECT_EQ(0.75, dummy.opacity());
 532 }
 533
 534 TEST(CCLayerAnimationControllerTest, ForceSyncWhenSynchronizedStartTimeNeeded)
 535 {
 536     FakeLayerAnimationControllerClient dummyImpl;
 537     OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController::create(&dummyImpl));
 538     OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
 539     FakeLayerAnimationControllerClient dummy;
 540     OwnPtr<CCLayerAnimationController> controller(
 541         CCLayerAnimationController::create(&dummy));
 542
 543     OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(2, 0, 1)), 0, CCActiveAnimation::Opacity));
 544     toAdd->setNeedsSynchronizedStartTime(true);
 545     controller->addAnimation(toAdd.release());
 546
 547     controller->animate(0, 0);
 548     EXPECT_TRUE(controller->hasActiveAnimation());
 549     CCActiveAnimation* activeAnimation = controller->getActiveAnimation(0, CCActiveAnimation::Opacity);
 550     EXPECT_TRUE(activeAnimation);
 551     EXPECT_TRUE(activeAnimation->needsSynchronizedStartTime());
 552
 553     controller->setForceSync();
 554
 555     controller->pushAnimationUpdatesTo(controllerImpl.get());
 556
 557     activeAnimation = controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity);
 558     EXPECT_TRUE(activeAnimation);
 559     EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, activeAnimation->runState());
 560 }
 561
 562 } // namespace