Web-Animations: Implement idle state for AnimationPlayers

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 34 matching lines @@
 {
     static unsigned next = 0;
     return ++next;
 }
 
 }
 
 PassRefPtrWillBeRawPtr<AnimationPlayer> AnimationPlayer::create(ExecutionContext* executionContext, AnimationTimeline& timeline, AnimationNode* content)
 {
     RefPtrWillBeRawPtr<AnimationPlayer> player = adoptRefWillBeNoop(new AnimationPlayer(executionContext, timeline, content));
+    player->uncancel();
     timeline.document()->compositorPendingAnimations().add(player.get());
     player->suspendIfNeeded();
     return player.release();
 }
 
 AnimationPlayer::AnimationPlayer(ExecutionContext* executionContext, AnimationTimeline& timeline, AnimationNode* content)
     : ActiveDOMObject(executionContext)
     , m_playbackRate(1)
     , m_startTime(nullValue())
     , m_holdTime(0)
     , m_sequenceNumber(nextSequenceNumber())
     , m_content(content)
     , m_timeline(&timeline)
     , m_paused(false)
     , m_held(true)
     , m_isPausedForTesting(false)
     , m_outdated(true)
-    , m_finished(false)
+    , m_finished(true)
     , m_compositorState(nullptr)
     , m_compositorPending(true)
     , m_currentTimePending(false)
+    , m_idle(true)
 {
     if (m_content) {
-        if (m_content->player())
+        if (m_content->player()) {
             m_content->player()->cancel();
+            m_content->player()->setSource(0);
+        }
         m_content->attach(this);
     }
 }
 
 AnimationPlayer::~AnimationPlayer()
 {
 #if !ENABLE(OILPAN)
     if (m_content)
         m_content->detach();
     if (m_timeline)
@@ skipping 53 matching lines @@
     m_holdTime = m_playbackRate < 0 ? 0 : sourceEnd();
 }
 
 double AnimationPlayer::startTime() const
 {
     return m_startTime * 1000;
 }
 
 double AnimationPlayer::currentTime()
 {
-    if (m_currentTimePending)
+    if (m_currentTimePending || m_idle)
         return std::numeric_limits<double>::quiet_NaN();
     return currentTimeInternal() * 1000;
 }
 
 double AnimationPlayer::currentTimeInternal()
 {
     updateCurrentTimingState(TimingUpdateOnDemand);
     if (m_held)
         return m_holdTime;
     return calculateCurrentTime();
@@ skipping 187 matching lines @@
         return;
 
     setCompositorPending(true);
 
     double storedCurrentTime = currentTimeInternal();
     if (m_content)
         m_content->detach();
     m_content = newSource;
     if (newSource) {
         // FIXME: This logic needs to be updated once groups are implemented
-        if (newSource->player())
+        if (newSource->player()) {
             newSource->player()->cancel();
+            newSource->player()->setSource(0);
+        }
         newSource->attach(this);
         setOutdated();
     }
     setCurrentTimeInternal(storedCurrentTime, TimingUpdateOnDemand);
 }
 
 String AnimationPlayer::playState()
 {
     switch (playStateInternal()) {
     case Idle:
         return "idle";
     case Pending:
         return "pending";
     case Running:
         return "running";
     case Paused:
         return "paused";
     case Finished:
         return "finished";
     default:
         ASSERT_NOT_REACHED();
         return "";
     }
 }
 
 AnimationPlayer::AnimationPlayState AnimationPlayer::playStateInternal()
 {
-    // FIXME(shanestephens): Add clause for in-idle-state here.
+    if (m_idle)
+        return Idle;
     if (m_currentTimePending || (isNull(m_startTime) && !m_paused && m_playbackRate != 0))
         return Pending;
-    // FIXME(shanestephens): Add idle handling here.
     if (m_paused)
         return Paused;
     if (finished())
         return Finished;
     return Running;
 }
 
 void AnimationPlayer::pause()
 {
     if (m_paused)
@@ skipping 22 matching lines @@
     m_paused = false;
     setCurrentTimeInternal(currentTimeInternal(), TimingUpdateOnDemand);
 }
 
 void AnimationPlayer::play()
 {
     if (!playing())
         m_startTime = nullValue();
 
     setCompositorPending();
+    uncancel();
     unpauseInternal();
     if (!m_content)
         return;
     double currentTime = this->currentTimeInternal();
     if (m_playbackRate > 0 && (currentTime < 0 || currentTime >= sourceEnd()))
         setCurrentTimeInternal(0, TimingUpdateOnDemand);
     else if (m_playbackRate < 0 && (currentTime <= 0 || currentTime > sourceEnd()))
         setCurrentTimeInternal(sourceEnd(), TimingUpdateOnDemand);
     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();
 }
 
 void AnimationPlayer::finish(ExceptionState& exceptionState)
 {
     if (!m_playbackRate) {
         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);
     }
     ASSERT(finished());
 }
 
 const AtomicString& AnimationPlayer::interfaceName() const
 {
@@ skipping 102 matching lines @@
 
 bool AnimationPlayer::update(TimingUpdateReason reason)
 {
     if (!m_timeline)
         return false;
 
     updateCurrentTimingState(reason);
     m_outdated = false;
 
     if (m_content) {
-        double inheritedTime = isNull(m_timeline->currentTimeInternal()) ? nullValue() : currentTimeInternal();
+        double inheritedTime = m_idle || isNull(m_timeline->currentTimeInternal()) ? nullValue() : currentTimeInternal();
         m_content->updateInheritedTime(inheritedTime, reason);
     }
 
-    if (finished() && !m_finished) {
-        if (reason == TimingUpdateForAnimationFrame && hasStartTime()) {
+    if ((m_idle || finished()) && !m_finished) {
+        if (reason == TimingUpdateForAnimationFrame && (m_idle || hasStartTime())) {
             const AtomicString& eventType = EventTypeNames::finish;
             if (executionContext() && hasEventListeners(eventType)) {
-                m_pendingFinishedEvent = AnimationPlayerEvent::create(eventType, currentTime(), timeline()->currentTime());
+                double eventCurrentTime = currentTimeInternal() * 1000;
+                m_pendingFinishedEvent = AnimationPlayerEvent::create(eventType, eventCurrentTime, timeline()->currentTime());
                 m_pendingFinishedEvent->setTarget(this);
                 m_pendingFinishedEvent->setCurrentTarget(this);
                 m_timeline->document()->enqueueAnimationFrameEvent(m_pendingFinishedEvent);
             }
             m_finished = true;
         }
     }
     ASSERT(!m_outdated);
-    return !m_finished || !finished();
+    return !m_finished;
 }
 
 double AnimationPlayer::timeToEffectChange()
 {
     ASSERT(!m_outdated);
     if (m_held || !hasStartTime())
         return std::numeric_limits<double>::infinity();
     if (!m_content)
         return -currentTimeInternal() / m_playbackRate;
     if (m_playbackRate > 0)
         return m_content->timeToForwardsEffectChange() / m_playbackRate;
     return m_content->timeToReverseEffectChange() / -m_playbackRate;
 }
 
 void AnimationPlayer::cancel()
 {
-    setSource(0);
+    m_holdTime = currentTimeInternal();
+    m_held = true;
+    m_idle = true;
+    m_startTime = nullValue();
+    setCompositorPending();
 }
 
 #if !ENABLE(OILPAN)
 bool AnimationPlayer::canFree() const
 {
     ASSERT(m_content);
     return hasOneRef() && m_content->isAnimation() && m_content->hasOneRef();
 }
 #endif
 
@@ skipping 16 matching lines @@
 
 void AnimationPlayer::trace(Visitor* visitor)
 {
     visitor->trace(m_content);
     visitor->trace(m_timeline);
     visitor->trace(m_pendingFinishedEvent);
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace