Web Animations: Implement the AnimationPlayer finished promise

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 519 matching lines @@
     setCurrentTimeInternal(newCurrentTime, TimingUpdateOnDemand);
     if (!paused()) {
         m_startTime = calculateStartTime(newCurrentTime);
     }
 
     m_currentTimePending = false;
     ASSERT(playStateInternal() != Idle);
     ASSERT(limited());
 }
 
+ScriptPromise AnimationPlayer::finished(ScriptState* scriptState)
+{
+    if (!m_finishedPromise) {
+        m_finishedPromise = new AnimationPlayerPromise(scriptState->executionContext(), this, AnimationPlayerPromise::Finished);
+        if (playStateInternal() == Finished)
+            m_finishedPromise->resolve(this);
+    }
+    return m_finishedPromise->promise(scriptState->world());
+}
+
 const AtomicString& AnimationPlayer::interfaceName() const
 {
     return EventTargetNames::AnimationPlayer;
 }
 
 ExecutionContext* AnimationPlayer::executionContext() const
 {
     return ActiveDOMObject::executionContext();
 }
 
@@ skipping 204 matching lines @@
 }
 
 void AnimationPlayer::endUpdatingState()
 {
     ASSERT(m_stateIsBeingUpdated);
     m_stateIsBeingUpdated = false;
 }
 
 AnimationPlayer::PlayStateUpdateScope::PlayStateUpdateScope(AnimationPlayer& player, TimingUpdateReason reason, CompositorPendingChange compositorPendingChange)
     : m_player(player)
-    , m_initial(m_player->playStateInternal())
+    , m_initialPlayState(m_player->playStateInternal())
     , m_compositorPendingChange(compositorPendingChange)
 {
     m_player->beginUpdatingState();
     m_player->updateCurrentTimingState(reason);
 }
 
 AnimationPlayer::PlayStateUpdateScope::~PlayStateUpdateScope()
 {
-    AnimationPlayState oldPlayState = m_initial;
+    AnimationPlayState oldPlayState = m_initialPlayState;
     AnimationPlayState newPlayState = m_player->calculatePlayState();
     if (oldPlayState != newPlayState) {
         bool wasActive = oldPlayState == Pending || oldPlayState == Running;
         bool isActive = newPlayState == Pending || newPlayState == Running;
         if (!wasActive && isActive) {
             if (m_player->m_content) {
                 TRACE_EVENT_ASYNC_BEGIN1("blink", "Animation", &m_player, "Name", TRACE_STR_COPY(m_player->m_content->name().utf8().data()));
             } else {
                 TRACE_EVENT_ASYNC_BEGIN0("blink", "Animation", &m_player);
             }
         } else if (wasActive && !isActive) {
             if (oldPlayState != Idle && oldPlayState != Finished) {
                 TRACE_EVENT_ASYNC_END0("blink", "Animation", &m_player);
             }
         }
         if (isActive) {
             TRACE_EVENT_ASYNC_STEP_INTO0("blink", "Animation", &m_player, playStateString(newPlayState));
         }
     }
 
+    if (m_player->m_finishedPromise && newPlayState != oldPlayState) {
+        if (newPlayState == Idle) {
+            if (m_player->m_finishedPromise->state() == AnimationPlayerPromise::Pending) {
+                m_player->m_finishedPromise->reject(DOMException::create(AbortError));
+            }
+            m_player->m_finishedPromise->reset();
+        }
+
+        if (newPlayState == Finished) {
+            m_player->m_finishedPromise->resolve(m_player);
+        }
+
+        if (oldPlayState == Finished) {
+            m_player->m_finishedPromise->reset();
+        }
+    }
+
     if (oldPlayState != newPlayState && (oldPlayState == Idle || newPlayState == Idle)) {
         m_player->setOutdated();
     }
 
     m_player->m_playState = newPlayState;
 
 #if ENABLE(ASSERT)
     // Verify that current time is up to date.
     m_player->currentTimeInternal();
 #endif
@@ skipping 38 matching lines @@
         toAnimation(m_content.get())->pauseAnimationForTestingOnCompositor(currentTimeInternal());
     m_isPausedForTesting = true;
     pause();
 }
 
 void AnimationPlayer::trace(Visitor* visitor)
 {
     visitor->trace(m_content);
     visitor->trace(m_timeline);
     visitor->trace(m_pendingFinishedEvent);
+    visitor->trace(m_finishedPromise);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace