src/third_party/WebKit/Source/core/animation/AnimationPlayerTest.cpp

   1 /*
   2  * Copyright (c) 2013, Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "core/animation/AnimationPlayer.h"
  33
  34 #include "core/animation/ActiveAnimations.h"
  35 #include "core/animation/Animation.h"
  36 #include "core/animation/AnimationClock.h"
  37 #include "core/animation/AnimationTimeline.h"
  38 #include "core/dom/Document.h"
  39 #include "core/dom/QualifiedName.h"
  40 #include "platform/weborigin/KURL.h"
  41 #include <gtest/gtest.h>
  42
  43 using namespace blink;
  44
  45 namespace {
  46
  47 class AnimationAnimationPlayerTest : public ::testing::Test {
  48 protected:
  49     virtual void SetUp()
  50     {
  51         setUpWithoutStartingTimeline();
  52         startTimeline();
  53     }
  54
  55     void setUpWithoutStartingTimeline()
  56     {
  57         document = Document::create();
  58         document->animationClock().resetTimeForTesting();
  59         timeline = AnimationTimeline::create(document.get());
  60         player = timeline->createAnimationPlayer(0);
  61         player->setStartTime(0);
  62         player->setSource(makeAnimation().get());
  63     }
  64
  65     void startTimeline()
  66     {
  67         simulateFrame(0);
  68     }
  69
  70     PassRefPtrWillBeRawPtr<Animation> makeAnimation(double duration = 30, double playbackRate = 1)
  71     {
  72         Timing timing;
  73         timing.iterationDuration = duration;
  74         timing.playbackRate = playbackRate;
  75         return Animation::create(0, nullptr, timing);
  76     }
  77
  78     bool simulateFrame(double time)
  79     {
  80         document->animationClock().updateTime(time);
  81         document->compositorPendingAnimations().update(false);
  82         // The timeline does not know about our player, so we have to explicitly call update().
  83         return player->update(TimingUpdateForAnimationFrame);
  84     }
  85
  86     RefPtrWillBePersistent<Document> document;
  87     RefPtrWillBePersistent<AnimationTimeline> timeline;
  88     RefPtrWillBePersistent<AnimationPlayer> player;
  89     TrackExceptionState exceptionState;
  90 };
  91
  92 TEST_F(AnimationAnimationPlayerTest, InitialState)
  93 {
  94     setUpWithoutStartingTimeline();
  95     player = timeline->createAnimationPlayer(0);
  96     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
  97     EXPECT_EQ(0, player->currentTimeInternal());
  98     EXPECT_FALSE(player->paused());
  99     EXPECT_EQ(1, player->playbackRate());
 100     EXPECT_FALSE(player->hasStartTime());
 101     EXPECT_TRUE(isNull(player->startTimeInternal()));
 102
 103     startTimeline();
 104     EXPECT_EQ(AnimationPlayer::Finished, player->playStateInternal());
 105     EXPECT_EQ(0, timeline->currentTimeInternal());
 106     EXPECT_EQ(0, player->currentTimeInternal());
 107     EXPECT_FALSE(player->paused());
 108     EXPECT_EQ(1, player->playbackRate());
 109     EXPECT_EQ(0, player->startTimeInternal());
 110     EXPECT_TRUE(player->hasStartTime());
 111 }
 112
 113
 114 TEST_F(AnimationAnimationPlayerTest, CurrentTimeDoesNotSetOutdated)
 115 {
 116     EXPECT_FALSE(player->outdated());
 117     EXPECT_EQ(0, player->currentTimeInternal());
 118     EXPECT_FALSE(player->outdated());
 119     // FIXME: We should split simulateFrame into a version that doesn't update
 120     // the player and one that does, as most of the tests don't require update()
 121     // to be called.
 122     document->animationClock().updateTime(10);
 123     EXPECT_EQ(10, player->currentTimeInternal());
 124     EXPECT_FALSE(player->outdated());
 125 }
 126
 127 TEST_F(AnimationAnimationPlayerTest, SetCurrentTime)
 128 {
 129     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 130     player->setCurrentTimeInternal(10);
 131     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 132     EXPECT_EQ(10, player->currentTimeInternal());
 133     simulateFrame(10);
 134     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 135     EXPECT_EQ(20, player->currentTimeInternal());
 136 }
 137
 138 TEST_F(AnimationAnimationPlayerTest, SetCurrentTimeNegative)
 139 {
 140     player->setCurrentTimeInternal(-10);
 141     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 142     EXPECT_EQ(-10, player->currentTimeInternal());
 143     simulateFrame(20);
 144     EXPECT_EQ(10, player->currentTimeInternal());
 145
 146     player->setPlaybackRate(-2);
 147     player->setCurrentTimeInternal(-10);
 148     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 149     EXPECT_EQ(-10, player->currentTimeInternal());
 150     simulateFrame(40);
 151     EXPECT_EQ(AnimationPlayer::Finished, player->playStateInternal());
 152     EXPECT_EQ(-10, player->currentTimeInternal());
 153 }
 154
 155 TEST_F(AnimationAnimationPlayerTest, SetCurrentTimeNegativeWithoutSimultaneousPlaybackRateChange)
 156 {
 157     simulateFrame(20);
 158     EXPECT_EQ(20, player->currentTimeInternal());
 159     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 160     player->setPlaybackRate(-1);
 161     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 162     simulateFrame(30);
 163     EXPECT_EQ(20, player->currentTimeInternal());
 164     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 165     player->setCurrentTimeInternal(-10);
 166     EXPECT_EQ(AnimationPlayer::Finished, player->playStateInternal());
 167 }
 168
 169 TEST_F(AnimationAnimationPlayerTest, SetCurrentTimePastContentEnd)
 170 {
 171     player->setCurrentTimeInternal(50);
 172     EXPECT_EQ(AnimationPlayer::Finished, player->playStateInternal());
 173     EXPECT_EQ(50, player->currentTimeInternal());
 174     simulateFrame(20);
 175     EXPECT_EQ(AnimationPlayer::Finished, player->playStateInternal());
 176     EXPECT_EQ(50, player->currentTimeInternal());
 177
 178     player->setPlaybackRate(-2);
 179     player->setCurrentTimeInternal(50);
 180     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 181     EXPECT_EQ(50, player->currentTimeInternal());
 182     simulateFrame(20);
 183     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 184     simulateFrame(40);
 185     EXPECT_EQ(10, player->currentTimeInternal());
 186 }
 187
 188 TEST_F(AnimationAnimationPlayerTest, SetCurrentTimeBeforeTimelineStarted)
 189 {
 190     setUpWithoutStartingTimeline();
 191     player->setCurrentTimeInternal(5);
 192     EXPECT_EQ(5, player->currentTimeInternal());
 193     startTimeline();
 194     simulateFrame(10);
 195     EXPECT_EQ(15, player->currentTimeInternal());
 196 }
 197
 198 TEST_F(AnimationAnimationPlayerTest, SetCurrentTimePastContentEndBeforeTimelineStarted)
 199 {
 200     setUpWithoutStartingTimeline();
 201     player->setCurrentTimeInternal(250);
 202     EXPECT_EQ(250, player->currentTimeInternal());
 203     startTimeline();
 204     simulateFrame(10);
 205     EXPECT_EQ(250, player->currentTimeInternal());
 206 }
 207
 208 TEST_F(AnimationAnimationPlayerTest, SetCurrentTimeMax)
 209 {
 210     player->setCurrentTimeInternal(std::numeric_limits<double>::max());
 211     EXPECT_EQ(std::numeric_limits<double>::max(), player->currentTimeInternal());
 212     simulateFrame(100);
 213     EXPECT_EQ(std::numeric_limits<double>::max(), player->currentTimeInternal());
 214 }
 215
 216 TEST_F(AnimationAnimationPlayerTest, SetCurrentTimeUnrestrictedDouble)
 217 {
 218     simulateFrame(10);
 219     player->setCurrentTime(nullValue());
 220     EXPECT_EQ(10, player->currentTimeInternal());
 221     player->setCurrentTime(std::numeric_limits<double>::infinity());
 222     EXPECT_EQ(10, player->currentTimeInternal());
 223     player->setCurrentTime(-std::numeric_limits<double>::infinity());
 224     EXPECT_EQ(10, player->currentTimeInternal());
 225 }
 226
 227
 228 TEST_F(AnimationAnimationPlayerTest, SetCurrentTimeSetsStartTime)
 229 {
 230     EXPECT_EQ(0, player->startTime());
 231     player->setCurrentTime(1000);
 232     EXPECT_EQ(-1000, player->startTime());
 233     simulateFrame(1);
 234     EXPECT_EQ(-1000, player->startTime());
 235     EXPECT_EQ(2000, player->currentTime());
 236 }
 237
 238 TEST_F(AnimationAnimationPlayerTest, SetStartTime)
 239 {
 240     simulateFrame(20);
 241     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 242     EXPECT_EQ(0, player->startTimeInternal());
 243     EXPECT_EQ(20, player->currentTimeInternal());
 244     player->setStartTime(10 * 1000);
 245     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 246     EXPECT_EQ(10, player->startTimeInternal());
 247     EXPECT_EQ(10, player->currentTimeInternal());
 248     simulateFrame(30);
 249     EXPECT_EQ(10, player->startTimeInternal());
 250     EXPECT_EQ(20, player->currentTimeInternal());
 251     player->setStartTime(-20 * 1000);
 252     EXPECT_EQ(AnimationPlayer::Finished, player->playStateInternal());
 253 }
 254
 255 TEST_F(AnimationAnimationPlayerTest, SetStartTimeLimitsAnimationPlayer)
 256 {
 257     player->setStartTime(-50 * 1000);
 258     EXPECT_EQ(AnimationPlayer::Finished, player->playStateInternal());
 259     EXPECT_EQ(30, player->currentTimeInternal());
 260     player->setPlaybackRate(-1);
 261     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 262     player->setStartTime(-100 * 1000);
 263     EXPECT_EQ(AnimationPlayer::Finished, player->playStateInternal());
 264     EXPECT_EQ(0, player->currentTimeInternal());
 265     EXPECT_TRUE(player->finished());
 266 }
 267
 268 TEST_F(AnimationAnimationPlayerTest, SetStartTimeOnLimitedAnimationPlayer)
 269 {
 270     simulateFrame(30);
 271     player->setStartTime(-10 * 1000);
 272     EXPECT_EQ(AnimationPlayer::Finished, player->playStateInternal());
 273     EXPECT_EQ(30, player->currentTimeInternal());
 274     player->setCurrentTimeInternal(50);
 275     player->setStartTime(-40 * 1000);
 276     EXPECT_EQ(30, player->currentTimeInternal());
 277     EXPECT_EQ(AnimationPlayer::Finished, player->playStateInternal());
 278     EXPECT_TRUE(player->finished());
 279 }
 280
 281 TEST_F(AnimationAnimationPlayerTest, StartTimePauseFinish)
 282 {
 283     player->pause();
 284     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 285     EXPECT_TRUE(std::isnan(player->startTime()));
 286     player->finish(exceptionState);
 287     EXPECT_EQ(AnimationPlayer::Paused, player->playStateInternal());
 288     EXPECT_TRUE(std::isnan(player->startTime()));
 289 }
 290
 291 TEST_F(AnimationAnimationPlayerTest, PauseBeatsFinish)
 292 {
 293     player->pause();
 294     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 295     simulateFrame(10);
 296     EXPECT_EQ(AnimationPlayer::Paused, player->playStateInternal());
 297     player->finish(exceptionState);
 298     EXPECT_EQ(AnimationPlayer::Paused, player->playStateInternal());
 299 }
 300
 301 TEST_F(AnimationAnimationPlayerTest, StartTimeFinishPause)
 302 {
 303     player->finish(exceptionState);
 304     EXPECT_EQ(-30 * 1000, player->startTime());
 305     player->pause();
 306     EXPECT_TRUE(std::isnan(player->startTime()));
 307 }
 308
 309 TEST_F(AnimationAnimationPlayerTest, StartTimeWithZeroPlaybackRate)
 310 {
 311     player->setPlaybackRate(0);
 312     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 313     EXPECT_TRUE(std::isnan(player->startTime()));
 314     simulateFrame(10);
 315     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 316 }
 317
 318 TEST_F(AnimationAnimationPlayerTest, PausePlay)
 319 {
 320     simulateFrame(10);
 321     player->pause();
 322     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 323     EXPECT_TRUE(player->paused());
 324     EXPECT_EQ(10, player->currentTimeInternal());
 325     simulateFrame(20);
 326     EXPECT_EQ(AnimationPlayer::Paused, player->playStateInternal());
 327     player->play();
 328     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 329     simulateFrame(20);
 330     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 331     EXPECT_FALSE(player->paused());
 332     EXPECT_EQ(10, player->currentTimeInternal());
 333     simulateFrame(30);
 334     EXPECT_EQ(20, player->currentTimeInternal());
 335 }
 336
 337 TEST_F(AnimationAnimationPlayerTest, PauseBeforeTimelineStarted)
 338 {
 339     setUpWithoutStartingTimeline();
 340     player->pause();
 341     EXPECT_TRUE(player->paused());
 342     player->play();
 343     EXPECT_FALSE(player->paused());
 344
 345     player->pause();
 346     startTimeline();
 347     simulateFrame(100);
 348     EXPECT_TRUE(player->paused());
 349     EXPECT_EQ(0, player->currentTimeInternal());
 350 }
 351
 352 TEST_F(AnimationAnimationPlayerTest, PlayRewindsToStart)
 353 {
 354     player->setCurrentTimeInternal(30);
 355     player->play();
 356     EXPECT_EQ(0, player->currentTimeInternal());
 357
 358     player->setCurrentTimeInternal(40);
 359     player->play();
 360     EXPECT_EQ(0, player->currentTimeInternal());
 361     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 362     simulateFrame(10);
 363     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 364
 365     player->setCurrentTimeInternal(-10);
 366     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 367     player->play();
 368     EXPECT_EQ(0, player->currentTimeInternal());
 369     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 370 }
 371
 372 TEST_F(AnimationAnimationPlayerTest, PlayRewindsToEnd)
 373 {
 374     player->setPlaybackRate(-1);
 375     player->play();
 376     EXPECT_EQ(30, player->currentTimeInternal());
 377
 378     player->setCurrentTimeInternal(40);
 379     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 380     player->play();
 381     EXPECT_EQ(30, player->currentTimeInternal());
 382     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 383     simulateFrame(10);
 384     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 385
 386     player->setCurrentTimeInternal(-10);
 387     player->play();
 388     EXPECT_EQ(30, player->currentTimeInternal());
 389     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 390     simulateFrame(20);
 391     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 392 }
 393
 394 TEST_F(AnimationAnimationPlayerTest, PlayWithPlaybackRateZeroDoesNotSeek)
 395 {
 396     player->setPlaybackRate(0);
 397     player->play();
 398     EXPECT_EQ(0, player->currentTimeInternal());
 399
 400     player->setCurrentTimeInternal(40);
 401     player->play();
 402     EXPECT_EQ(40, player->currentTimeInternal());
 403
 404     player->setCurrentTimeInternal(-10);
 405     player->play();
 406     EXPECT_EQ(-10, player->currentTimeInternal());
 407 }
 408
 409 TEST_F(AnimationAnimationPlayerTest, PlayAfterPauseWithPlaybackRateZeroUpdatesPlayState)
 410 {
 411     player->pause();
 412     player->setPlaybackRate(0);
 413     simulateFrame(1);
 414     EXPECT_EQ(AnimationPlayer::Paused, player->playStateInternal());
 415     player->play();
 416     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 417 }
 418
 419 TEST_F(AnimationAnimationPlayerTest, Reverse)
 420 {
 421     player->setCurrentTimeInternal(10);
 422     player->pause();
 423     player->reverse();
 424     EXPECT_FALSE(player->paused());
 425     EXPECT_EQ(-1, player->playbackRate());
 426     EXPECT_EQ(10, player->currentTimeInternal());
 427 }
 428
 429 TEST_F(AnimationAnimationPlayerTest, ReverseDoesNothingWithPlaybackRateZero)
 430 {
 431     player->setCurrentTimeInternal(10);
 432     player->setPlaybackRate(0);
 433     player->pause();
 434     player->reverse();
 435     EXPECT_TRUE(player->paused());
 436     EXPECT_EQ(0, player->playbackRate());
 437     EXPECT_EQ(10, player->currentTimeInternal());
 438 }
 439
 440 TEST_F(AnimationAnimationPlayerTest, ReverseDoesNotSeekWithNoSource)
 441 {
 442     player->setSource(0);
 443     player->setCurrentTimeInternal(10);
 444     player->reverse();
 445     EXPECT_EQ(10, player->currentTimeInternal());
 446 }
 447
 448 TEST_F(AnimationAnimationPlayerTest, ReverseSeeksToStart)
 449 {
 450     player->setCurrentTimeInternal(-10);
 451     player->setPlaybackRate(-1);
 452     player->reverse();
 453     EXPECT_EQ(0, player->currentTimeInternal());
 454 }
 455
 456 TEST_F(AnimationAnimationPlayerTest, ReverseSeeksToEnd)
 457 {
 458     player->setCurrentTimeInternal(40);
 459     player->reverse();
 460     EXPECT_EQ(30, player->currentTimeInternal());
 461 }
 462
 463 TEST_F(AnimationAnimationPlayerTest, ReverseBeyondLimit)
 464 {
 465     player->setCurrentTimeInternal(40);
 466     player->setPlaybackRate(-1);
 467     player->reverse();
 468     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 469     EXPECT_EQ(0, player->currentTimeInternal());
 470
 471     player->setCurrentTimeInternal(-10);
 472     player->reverse();
 473     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 474     EXPECT_EQ(30, player->currentTimeInternal());
 475 }
 476
 477
 478 TEST_F(AnimationAnimationPlayerTest, Finish)
 479 {
 480     player->finish(exceptionState);
 481     EXPECT_EQ(30, player->currentTimeInternal());
 482     EXPECT_TRUE(player->finished());
 483
 484     player->setPlaybackRate(-1);
 485     player->finish(exceptionState);
 486     EXPECT_EQ(0, player->currentTimeInternal());
 487     EXPECT_TRUE(player->finished());
 488
 489     EXPECT_FALSE(exceptionState.hadException());
 490 }
 491
 492 TEST_F(AnimationAnimationPlayerTest, FinishAfterSourceEnd)
 493 {
 494     player->setCurrentTimeInternal(40);
 495     player->finish(exceptionState);
 496     EXPECT_EQ(30, player->currentTimeInternal());
 497 }
 498
 499 TEST_F(AnimationAnimationPlayerTest, FinishBeforeStart)
 500 {
 501     player->setCurrentTimeInternal(-10);
 502     player->setPlaybackRate(-1);
 503     player->finish(exceptionState);
 504     EXPECT_EQ(0, player->currentTimeInternal());
 505 }
 506
 507 TEST_F(AnimationAnimationPlayerTest, FinishDoesNothingWithPlaybackRateZero)
 508 {
 509     player->setCurrentTimeInternal(10);
 510     player->setPlaybackRate(0);
 511     player->finish(exceptionState);
 512     EXPECT_EQ(10, player->currentTimeInternal());
 513 }
 514
 515 TEST_F(AnimationAnimationPlayerTest, FinishRaisesException)
 516 {
 517     Timing timing;
 518     timing.iterationDuration = 1;
 519     timing.iterationCount = std::numeric_limits<double>::infinity();
 520     player->setSource(Animation::create(0, nullptr, timing).get());
 521     player->setCurrentTimeInternal(10);
 522
 523     player->finish(exceptionState);
 524     EXPECT_EQ(10, player->currentTimeInternal());
 525     EXPECT_TRUE(exceptionState.hadException());
 526     EXPECT_EQ(InvalidStateError, exceptionState.code());
 527 }
 528
 529
 530 TEST_F(AnimationAnimationPlayerTest, LimitingAtSourceEnd)
 531 {
 532     simulateFrame(30);
 533     EXPECT_EQ(30, player->currentTimeInternal());
 534     EXPECT_TRUE(player->finished());
 535     simulateFrame(40);
 536     EXPECT_EQ(30, player->currentTimeInternal());
 537     EXPECT_FALSE(player->paused());
 538 }
 539
 540 TEST_F(AnimationAnimationPlayerTest, LimitingAtStart)
 541 {
 542     simulateFrame(30);
 543     player->setPlaybackRate(-2);
 544     simulateFrame(30);
 545     simulateFrame(45);
 546     EXPECT_EQ(0, player->currentTimeInternal());
 547     EXPECT_TRUE(player->finished());
 548     simulateFrame(60);
 549     EXPECT_EQ(0, player->currentTimeInternal());
 550     EXPECT_FALSE(player->paused());
 551 }
 552
 553 TEST_F(AnimationAnimationPlayerTest, LimitingWithNoSource)
 554 {
 555     player->setSource(0);
 556     EXPECT_TRUE(player->finished());
 557     simulateFrame(30);
 558     EXPECT_EQ(0, player->currentTimeInternal());
 559 }
 560
 561
 562 TEST_F(AnimationAnimationPlayerTest, SetPlaybackRate)
 563 {
 564     player->setPlaybackRate(2);
 565     simulateFrame(0);
 566     EXPECT_EQ(2, player->playbackRate());
 567     EXPECT_EQ(0, player->currentTimeInternal());
 568     simulateFrame(10);
 569     EXPECT_EQ(20, player->currentTimeInternal());
 570 }
 571
 572 TEST_F(AnimationAnimationPlayerTest, SetPlaybackRateBeforeTimelineStarted)
 573 {
 574     setUpWithoutStartingTimeline();
 575     player->setPlaybackRate(2);
 576     EXPECT_EQ(2, player->playbackRate());
 577     EXPECT_EQ(0, player->currentTimeInternal());
 578     startTimeline();
 579     simulateFrame(10);
 580     EXPECT_EQ(20, player->currentTimeInternal());
 581 }
 582
 583 TEST_F(AnimationAnimationPlayerTest, SetPlaybackRateWhilePaused)
 584 {
 585     simulateFrame(10);
 586     player->pause();
 587     player->setPlaybackRate(2);
 588     simulateFrame(20);
 589     player->play();
 590     EXPECT_EQ(10, player->currentTimeInternal());
 591     simulateFrame(20);
 592     simulateFrame(25);
 593     EXPECT_EQ(20, player->currentTimeInternal());
 594 }
 595
 596 TEST_F(AnimationAnimationPlayerTest, SetPlaybackRateWhileLimited)
 597 {
 598     simulateFrame(40);
 599     EXPECT_EQ(30, player->currentTimeInternal());
 600     player->setPlaybackRate(2);
 601     simulateFrame(50);
 602     EXPECT_EQ(30, player->currentTimeInternal());
 603     player->setPlaybackRate(-2);
 604     simulateFrame(50);
 605     simulateFrame(60);
 606     EXPECT_FALSE(player->finished());
 607     EXPECT_EQ(10, player->currentTimeInternal());
 608 }
 609
 610 TEST_F(AnimationAnimationPlayerTest, SetPlaybackRateZero)
 611 {
 612     simulateFrame(0);
 613     simulateFrame(10);
 614     player->setPlaybackRate(0);
 615     simulateFrame(10);
 616     EXPECT_EQ(10, player->currentTimeInternal());
 617     simulateFrame(20);
 618     EXPECT_EQ(10, player->currentTimeInternal());
 619     player->setCurrentTimeInternal(20);
 620     EXPECT_EQ(20, player->currentTimeInternal());
 621 }
 622
 623 TEST_F(AnimationAnimationPlayerTest, SetPlaybackRateMax)
 624 {
 625     player->setPlaybackRate(std::numeric_limits<double>::max());
 626     simulateFrame(0);
 627     EXPECT_EQ(std::numeric_limits<double>::max(), player->playbackRate());
 628     EXPECT_EQ(0, player->currentTimeInternal());
 629     simulateFrame(1);
 630     EXPECT_EQ(30, player->currentTimeInternal());
 631 }
 632
 633
 634 TEST_F(AnimationAnimationPlayerTest, SetSource)
 635 {
 636     player = timeline->createAnimationPlayer(0);
 637     player->setStartTime(0);
 638     RefPtrWillBeRawPtr<AnimationNode> source1 = makeAnimation();
 639     RefPtrWillBeRawPtr<AnimationNode> source2 = makeAnimation();
 640     player->setSource(source1.get());
 641     EXPECT_EQ(source1, player->source());
 642     EXPECT_EQ(0, player->currentTimeInternal());
 643     player->setCurrentTimeInternal(15);
 644     player->setSource(source2.get());
 645     EXPECT_EQ(15, player->currentTimeInternal());
 646     EXPECT_EQ(0, source1->player());
 647     EXPECT_EQ(player.get(), source2->player());
 648     EXPECT_EQ(source2, player->source());
 649 }
 650
 651 TEST_F(AnimationAnimationPlayerTest, SetSourceLimitsAnimationPlayer)
 652 {
 653     player->setCurrentTimeInternal(20);
 654     player->setSource(makeAnimation(10).get());
 655     EXPECT_EQ(20, player->currentTimeInternal());
 656     EXPECT_TRUE(player->finished());
 657     simulateFrame(10);
 658     EXPECT_EQ(20, player->currentTimeInternal());
 659 }
 660
 661 TEST_F(AnimationAnimationPlayerTest, SetSourceUnlimitsAnimationPlayer)
 662 {
 663     player->setCurrentTimeInternal(40);
 664     player->setSource(makeAnimation(60).get());
 665     EXPECT_FALSE(player->finished());
 666     EXPECT_EQ(40, player->currentTimeInternal());
 667     simulateFrame(10);
 668     EXPECT_EQ(50, player->currentTimeInternal());
 669 }
 670
 671
 672 TEST_F(AnimationAnimationPlayerTest, EmptyAnimationPlayersDontUpdateEffects)
 673 {
 674     player = timeline->createAnimationPlayer(0);
 675     player->update(TimingUpdateOnDemand);
 676     EXPECT_EQ(std::numeric_limits<double>::infinity(), player->timeToEffectChange());
 677
 678     simulateFrame(1234);
 679     EXPECT_EQ(std::numeric_limits<double>::infinity(), player->timeToEffectChange());
 680 }
 681
 682 TEST_F(AnimationAnimationPlayerTest, AnimationPlayersDisassociateFromSource)
 683 {
 684     AnimationNode* animationNode = player->source();
 685     AnimationPlayer* player2 = timeline->createAnimationPlayer(animationNode);
 686     EXPECT_EQ(0, player->source());
 687     player->setSource(animationNode);
 688     EXPECT_EQ(0, player2->source());
 689 }
 690
 691 TEST_F(AnimationAnimationPlayerTest, AnimationPlayersReturnTimeToNextEffect)
 692 {
 693     Timing timing;
 694     timing.startDelay = 1;
 695     timing.iterationDuration = 1;
 696     timing.endDelay = 1;
 697     RefPtrWillBeRawPtr<Animation> animation = Animation::create(0, nullptr, timing);
 698     player = timeline->createAnimationPlayer(animation.get());
 699     player->setStartTime(0);
 700
 701     simulateFrame(0);
 702     EXPECT_EQ(1, player->timeToEffectChange());
 703
 704     simulateFrame(0.5);
 705     EXPECT_EQ(0.5, player->timeToEffectChange());
 706
 707     simulateFrame(1);
 708     EXPECT_EQ(0, player->timeToEffectChange());
 709
 710     simulateFrame(1.5);
 711     EXPECT_EQ(0, player->timeToEffectChange());
 712
 713     simulateFrame(2);
 714     EXPECT_EQ(std::numeric_limits<double>::infinity(), player->timeToEffectChange());
 715
 716     simulateFrame(3);
 717     EXPECT_EQ(std::numeric_limits<double>::infinity(), player->timeToEffectChange());
 718
 719     player->setCurrentTimeInternal(0);
 720     simulateFrame(3);
 721     EXPECT_EQ(1, player->timeToEffectChange());
 722
 723     player->setPlaybackRate(2);
 724     simulateFrame(3);
 725     EXPECT_EQ(0.5, player->timeToEffectChange());
 726
 727     player->setPlaybackRate(0);
 728     player->update(TimingUpdateOnDemand);
 729     EXPECT_EQ(std::numeric_limits<double>::infinity(), player->timeToEffectChange());
 730
 731     player->setCurrentTimeInternal(3);
 732     player->setPlaybackRate(-1);
 733     player->update(TimingUpdateOnDemand);
 734     simulateFrame(3);
 735     EXPECT_EQ(1, player->timeToEffectChange());
 736
 737     player->setPlaybackRate(-2);
 738     player->update(TimingUpdateOnDemand);
 739     simulateFrame(3);
 740     EXPECT_EQ(0.5, player->timeToEffectChange());
 741 }
 742
 743 TEST_F(AnimationAnimationPlayerTest, TimeToNextEffectWhenPaused)
 744 {
 745     EXPECT_EQ(0, player->timeToEffectChange());
 746     player->pause();
 747     player->update(TimingUpdateOnDemand);
 748     EXPECT_EQ(std::numeric_limits<double>::infinity(), player->timeToEffectChange());
 749 }
 750
 751 TEST_F(AnimationAnimationPlayerTest, TimeToNextEffectWhenCancelledBeforeStart)
 752 {
 753     EXPECT_EQ(0, player->timeToEffectChange());
 754     player->setCurrentTimeInternal(-8);
 755     player->setPlaybackRate(2);
 756     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 757     player->cancel();
 758     EXPECT_EQ(AnimationPlayer::Idle, player->playStateInternal());
 759     player->update(TimingUpdateOnDemand);
 760     // This frame will fire the finish event event though no start time has been
 761     // received from the compositor yet, as cancel() nukes start times.
 762     simulateFrame(0);
 763     EXPECT_EQ(std::numeric_limits<double>::infinity(), player->timeToEffectChange());
 764 }
 765
 766 TEST_F(AnimationAnimationPlayerTest, TimeToNextEffectWhenCancelledBeforeStartReverse)
 767 {
 768     EXPECT_EQ(0, player->timeToEffectChange());
 769     player->setCurrentTimeInternal(9);
 770     player->setPlaybackRate(-3);
 771     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 772     player->cancel();
 773     EXPECT_EQ(AnimationPlayer::Idle, player->playStateInternal());
 774     player->update(TimingUpdateOnDemand);
 775     // This frame will fire the finish event event though no start time has been
 776     // received from the compositor yet, as cancel() nukes start times.
 777     simulateFrame(0);
 778     EXPECT_EQ(std::numeric_limits<double>::infinity(), player->timeToEffectChange());
 779 }
 780
 781 TEST_F(AnimationAnimationPlayerTest, TimeToNextEffectSimpleCancelledBeforeStart)
 782 {
 783     EXPECT_EQ(0, player->timeToEffectChange());
 784     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 785     player->cancel();
 786     player->update(TimingUpdateOnDemand);
 787     // This frame will fire the finish event event though no start time has been
 788     // received from the compositor yet, as cancel() nukes start times.
 789     simulateFrame(0);
 790     EXPECT_EQ(std::numeric_limits<double>::infinity(), player->timeToEffectChange());
 791 }
 792
 793 TEST_F(AnimationAnimationPlayerTest, AttachedAnimationPlayers)
 794 {
 795     RefPtrWillBePersistent<Element> element = document->createElement("foo", ASSERT_NO_EXCEPTION);
 796
 797     Timing timing;
 798     RefPtrWillBeRawPtr<Animation> animation = Animation::create(element.get(), nullptr, timing);
 799     RefPtrWillBeRawPtr<AnimationPlayer> player = timeline->createAnimationPlayer(animation.get());
 800     simulateFrame(0);
 801     timeline->serviceAnimations(TimingUpdateForAnimationFrame);
 802     EXPECT_EQ(1U, element->activeAnimations()->players().find(player.get())->value);
 803
 804     player.release();
 805     Heap::collectAllGarbage();
 806     EXPECT_TRUE(element->activeAnimations()->players().isEmpty());
 807 }
 808
 809 TEST_F(AnimationAnimationPlayerTest, HasLowerPriority)
 810 {
 811     RefPtrWillBeRawPtr<AnimationPlayer> player1 = timeline->createAnimationPlayer(0);
 812     RefPtrWillBeRawPtr<AnimationPlayer> player2 = timeline->createAnimationPlayer(0);
 813     EXPECT_TRUE(AnimationPlayer::hasLowerPriority(player1.get(), player2.get()));
 814 }
 815
 816 TEST_F(AnimationAnimationPlayerTest, PlayAfterCancel)
 817 {
 818     player->cancel();
 819     EXPECT_EQ(AnimationPlayer::Idle, player->playStateInternal());
 820     EXPECT_TRUE(std::isnan(player->currentTime()));
 821     EXPECT_TRUE(std::isnan(player->startTime()));
 822     player->play();
 823     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 824     EXPECT_EQ(0, player->currentTime());
 825     EXPECT_TRUE(std::isnan(player->startTime()));
 826     simulateFrame(10);
 827     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 828     EXPECT_EQ(0, player->currentTime());
 829     EXPECT_EQ(10 * 1000, player->startTime());
 830 }
 831
 832 TEST_F(AnimationAnimationPlayerTest, PlayBackwardsAfterCancel)
 833 {
 834     player->setPlaybackRate(-1);
 835     player->setCurrentTime(15 * 1000);
 836     simulateFrame(0);
 837     player->cancel();
 838     EXPECT_EQ(AnimationPlayer::Idle, player->playStateInternal());
 839     EXPECT_TRUE(std::isnan(player->currentTime()));
 840     EXPECT_TRUE(std::isnan(player->startTime()));
 841     player->play();
 842     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 843     EXPECT_EQ(30 * 1000, player->currentTime());
 844     EXPECT_TRUE(std::isnan(player->startTime()));
 845     simulateFrame(10);
 846     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 847     EXPECT_EQ(30 * 1000, player->currentTime());
 848     EXPECT_EQ(40 * 1000, player->startTime());
 849 }
 850
 851 TEST_F(AnimationAnimationPlayerTest, ReverseAfterCancel)
 852 {
 853     player->cancel();
 854     EXPECT_EQ(AnimationPlayer::Idle, player->playStateInternal());
 855     EXPECT_TRUE(std::isnan(player->currentTime()));
 856     EXPECT_TRUE(std::isnan(player->startTime()));
 857     player->reverse();
 858     EXPECT_EQ(AnimationPlayer::Pending, player->playStateInternal());
 859     EXPECT_EQ(30 * 1000, player->currentTime());
 860     EXPECT_TRUE(std::isnan(player->startTime()));
 861     simulateFrame(10);
 862     EXPECT_EQ(AnimationPlayer::Running, player->playStateInternal());
 863     EXPECT_EQ(30 * 1000, player->currentTime());
 864     EXPECT_EQ(40 * 1000, player->startTime());
 865 }
 866
 867 TEST_F(AnimationAnimationPlayerTest, FinishAfterCancel)
 868 {
 869     player->cancel();
 870     EXPECT_EQ(AnimationPlayer::Idle, player->playStateInternal());
 871     EXPECT_TRUE(std::isnan(player->currentTime()));
 872     EXPECT_TRUE(std::isnan(player->startTime()));
 873     player->finish(exceptionState);
 874     EXPECT_TRUE(std::isnan(player->currentTime()));
 875     EXPECT_TRUE(std::isnan(player->startTime()));
 876     EXPECT_EQ(AnimationPlayer::Idle, player->playStateInternal());
 877 }
 878
 879 TEST_F(AnimationAnimationPlayerTest, PauseAfterCancel)
 880 {
 881     player->cancel();
 882     EXPECT_EQ(AnimationPlayer::Idle, player->playStateInternal());
 883     EXPECT_TRUE(std::isnan(player->currentTime()));
 884     EXPECT_TRUE(std::isnan(player->startTime()));
 885     player->pause();
 886     EXPECT_EQ(AnimationPlayer::Idle, player->playStateInternal());
 887     EXPECT_TRUE(std::isnan(player->currentTime()));
 888     EXPECT_TRUE(std::isnan(player->startTime()));
 889 }
 890
 891 }