Web Animations: Add tests for player state transitions and fix discovered issues

Source/core/animation/AnimationPlayer.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 275 matching lines @@
         return 0;
     return (m_timeline->effectiveTime() - m_startTime) * m_playbackRate;
 }
 
 void AnimationPlayer::setCurrentTime(double newCurrentTime)
 {
     if (!std::isfinite(newCurrentTime))
         return;
 
     setCompositorPending();
-
-    // Setting current time while pending forces a start time.
-    if (m_currentTimePending) {
-        m_startTime = 0;
-        m_currentTimePending = false;
-    }
-
+    m_currentTimePending = false;
     setCurrentTimeInternal(newCurrentTime / 1000, TimingUpdateOnDemand);
 }
 
 void AnimationPlayer::setStartTime(double startTime)
 {
-    if (m_paused) // FIXME: Should this throw an exception?
+    if (m_paused || m_idle)
         return;
     if (!std::isfinite(startTime))
         return;
     if (startTime == m_startTime)
         return;
 
     setCompositorPending();
     m_currentTimePending = false;
     setStartTimeInternal(startTime / 1000);
 }
@@ skipping 132 matching lines @@
     m_finished = false;
 }
 
 void AnimationPlayer::reverse()
 {
     if (!m_playbackRate) {
         return;
     }
 
     uncancel();
-
-    if (m_content) {
-        if (m_playbackRate > 0 && currentTimeInternal() > sourceEnd()) {
-            setCurrentTimeInternal(sourceEnd(), TimingUpdateOnDemand);
-            ASSERT(finished());
-        } else if (m_playbackRate < 0 && currentTimeInternal() < 0) {
-            setCurrentTimeInternal(0, TimingUpdateOnDemand);
-            ASSERT(finished());
-        }
-    }
     setPlaybackRate(-m_playbackRate);
-    unpauseInternal();
+    play();
 }
 
 void AnimationPlayer::finish(ExceptionState& exceptionState)
 {
-    if (!m_playbackRate) {
+    if (!m_playbackRate || m_idle) {
         return;
     }
     if (m_playbackRate > 0 && sourceEnd() == std::numeric_limits<double>::infinity()) {
         exceptionState.throwDOMException(InvalidStateError, "AnimationPlayer has source content whose end time is infinity.");
         return;
     }
     if (playing()) {
         setCompositorPending();
     }
 
     uncancel();
-    m_startTime = 0;
 
-    if (m_playbackRate < 0) {
-        setCurrentTimeInternal(0, TimingUpdateOnDemand);
-    } else {
-        setCurrentTimeInternal(sourceEnd(), TimingUpdateOnDemand);
+    double newCurrentTime = m_playbackRate < 0 ? 0 : sourceEnd();
+    setCurrentTimeInternal(newCurrentTime, TimingUpdateOnDemand);
+    if (!paused()) {
+        m_startTime = calculateStartTime(newCurrentTime);
     }
+
+    m_currentTimePending = false;
     ASSERT(finished());
 }
 
 const AtomicString& AnimationPlayer::interfaceName() const
 {
     return EventTargetNames::AnimationPlayer;
 }
 
 ExecutionContext* AnimationPlayer::executionContext() const
 {
@@ skipping 19 matching lines @@
 }
 
 void AnimationPlayer::setPlaybackRate(double playbackRate)
 {
     if (!std::isfinite(playbackRate))
         return;
     if (playbackRate == m_playbackRate)
         return;
 
     setCompositorPending();
-    if (!finished() && !paused())
+    if (!finished() && !paused() && hasStartTime())
         m_currentTimePending = true;
 
     double storedCurrentTime = currentTimeInternal();
     if ((m_playbackRate < 0 && playbackRate >= 0) || (m_playbackRate > 0 && playbackRate <= 0))
         m_finished = false;
 
     m_playbackRate = playbackRate;
     m_startTime = std::numeric_limits<double>::quiet_NaN();
     setCurrentTimeInternal(storedCurrentTime, TimingUpdateOnDemand);
 }
@@ skipping 96 matching lines @@
         return m_content->timeToForwardsEffectChange() / m_playbackRate;
     return m_content->timeToReverseEffectChange() / -m_playbackRate;
 }
 
 void AnimationPlayer::cancel()
 {
     m_holdTime = currentTimeInternal();
     m_held = true;
     m_idle = true;
     m_startTime = nullValue();
+    m_currentTimePending = false;
     setCompositorPending();
 }
 
 #if !ENABLE(OILPAN)
 bool AnimationPlayer::canFree() const
 {
     ASSERT(m_content);
     return hasOneRef() && m_content->isAnimation() && m_content->hasOneRef();
 }
 #endif
@@ skipping 17 matching lines @@
 
 void AnimationPlayer::trace(Visitor* visitor)
 {
     visitor->trace(m_content);
     visitor->trace(m_timeline);
     visitor->trace(m_pendingFinishedEvent);
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace