Fix Animations, Remove Compostior Animations.

sky/engine/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;
 }
 
 }
 
 PassRefPtr<AnimationPlayer> AnimationPlayer::create(ExecutionContext* executionContext, AnimationTimeline& timeline, AnimationNode* content)
 {
     RefPtr<AnimationPlayer> player = adoptRef(new AnimationPlayer(executionContext, timeline, content));
-    timeline.document()->compositorPendingAnimations().add(player.get());
+    timeline.document()->pendingAnimations().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_compositorState(nullptr)
-    , m_compositorPending(true)
+    , m_pending(true)
     , m_currentTimePending(false)
 {
     if (m_content) {
         if (m_content->player())
             m_content->player()->cancel();
         m_content->attach(this);
     }
 }
 
 AnimationPlayer::~AnimationPlayer()
@@ skipping 69 matching lines @@
 }
 
 double AnimationPlayer::currentTimeInternal()
 {
     updateCurrentTimingState(TimingUpdateOnDemand);
     if (m_held)
         return m_holdTime;
     return calculateCurrentTime();
 }
 
-void AnimationPlayer::preCommit(bool startOnCompositor)
+void AnimationPlayer::preCommit()
 {
-    if (m_compositorState && m_compositorState->pendingAction == Start) {
-        // Still waiting for a start time.
-        return;
-    }
-
-    bool softChange = m_compositorState && (paused() || m_compositorState->playbackRate != m_playbackRate);
-    bool hardChange = m_compositorState && (m_compositorState->sourceChanged || (m_compositorState->startTime != m_startTime && !std::isnan(m_compositorState->startTime) && !std::isnan(m_startTime)));
-
-    // FIXME: softChange && !hardChange should generate a Pause/ThenStart,
-    // not a Cancel, but we can't communicate these to the compositor yet.
-
-    bool changed = softChange || hardChange;
-    bool shouldCancel = (!playing() && m_compositorState) || changed;
-    bool shouldStart = playing() && (!m_compositorState || changed);
-
-    if (shouldCancel) {
-        cancelAnimationOnCompositor();
-        m_compositorState = nullptr;
-
-    }
-
-    if (!shouldStart) {
+    if (!playing()) {
         m_currentTimePending = false;
     }
-
-    if (shouldStart && startOnCompositor && maybeStartAnimationOnCompositor()) {
-        m_compositorState = adoptPtr(new CompositorState(*this));
-    }
 }
 
 void AnimationPlayer::postCommit(double timelineTime)
 {
-    m_compositorPending = false;
-
-    if (!m_compositorState || m_compositorState->pendingAction == None)
-        return;
-
-    switch (m_compositorState->pendingAction) {
-    case Start:
-        if (!std::isnan(m_compositorState->startTime)) {
-            ASSERT(m_startTime == m_compositorState->startTime);
-            m_compositorState->pendingAction = None;
-        }
-        break;
-    case Pause:
-    case PauseThenStart:
-        ASSERT(std::isnan(m_startTime));
-        m_compositorState->pendingAction = None;
-        setCurrentTimeInternal((timelineTime - m_compositorState->startTime) * m_playbackRate, TimingUpdateForAnimationFrame);
-        m_currentTimePending = false;
-        break;
-    default:
-        ASSERT_NOT_REACHED();
-    }
+    m_pending = false;
 }
 
 void AnimationPlayer::notifyCompositorStartTime(double timelineTime)
 {
-    if (m_compositorState) {
-        ASSERT(m_compositorState->pendingAction == Start);
-        ASSERT(std::isnan(m_compositorState->startTime));
-
-        double initialCompositorHoldTime = m_compositorState->holdTime;
-        m_compositorState->pendingAction = None;
-        m_compositorState->startTime = timelineTime;
-
-        if (paused() || m_compositorState->playbackRate != m_playbackRate || m_compositorState->sourceChanged) {
-            // Paused state, playback rate, or source changed while starting.
-            setCompositorPending();
-        }
-
-        if (m_startTime == timelineTime) {
-            // The start time was set to the incoming compositor start time.
-            // Unlikely, but possible.
-            // FIXME: Depending on what changed above this might still be pending.
-            // Maybe...
-            m_currentTimePending = false;
-            return;
-        }
-
-        if (!std::isnan(m_startTime) || currentTimeInternal() != initialCompositorHoldTime) {
-            // A new start time or current time was set while starting.
-            setCompositorPending();
-            return;
-        }
-    }
-
     if (playing()) {
         ASSERT(std::isnan(m_startTime));
         ASSERT(m_held);
 
         if (m_playbackRate == 0) {
             setStartTimeInternal(timelineTime);
         } else {
             setStartTimeInternal(timelineTime + currentTimeInternal() / -m_playbackRate);
         }
 
@@ skipping 16 matching lines @@
     if (isNull(m_startTime) || !m_timeline)
         return 0;
     return (m_timeline->effectiveTime() - m_startTime) * m_playbackRate;
 }
 
 void AnimationPlayer::setCurrentTime(double newCurrentTime)
 {
     if (!std::isfinite(newCurrentTime))
         return;
 
-    setCompositorPending();
+    setPending();
 
     // Setting current time while pending forces a start time.
     if (m_currentTimePending) {
         m_startTime = 0;
         m_currentTimePending = false;
     }
 
     setCurrentTimeInternal(newCurrentTime / 1000, TimingUpdateOnDemand);
 }
 
 void AnimationPlayer::setStartTime(double startTime)
 {
     if (m_paused) // FIXME: Should this throw an exception?
         return;
     if (!std::isfinite(startTime))
         return;
     if (startTime == m_startTime)
         return;
 
-    setCompositorPending();
+    setPending();
     m_currentTimePending = false;
     setStartTimeInternal(startTime / 1000);
 }
 
 void AnimationPlayer::setStartTimeInternal(double newStartTime)
 {
     ASSERT(!m_paused);
     ASSERT(std::isfinite(newStartTime));
     ASSERT(newStartTime != m_startTime);
 
@@ skipping 21 matching lines @@
         // infinity until start time is set.
         m_timeline->wake();
     }
 }
 
 void AnimationPlayer::setSource(AnimationNode* newSource)
 {
     if (m_content == newSource)
         return;
 
-    setCompositorPending(true);
+    setPending();
 
     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())
             newSource->player()->cancel();
         newSource->attach(this);
@@ skipping 32 matching lines @@
     if (finished())
         return Finished;
     return Running;
 }
 
 void AnimationPlayer::pause()
 {
     if (m_paused)
         return;
     if (playing()) {
-        setCompositorPending();
+        setPending();
         m_currentTimePending = true;
     }
     m_paused = true;
     setCurrentTimeInternal(currentTimeInternal(), TimingUpdateOnDemand);
 }
 
 void AnimationPlayer::unpause()
 {
     if (!m_paused)
         return;
-    setCompositorPending();
+    setPending();
     m_currentTimePending = true;
     unpauseInternal();
 }
 
 void AnimationPlayer::unpauseInternal()
 {
     if (!m_paused)
         return;
     m_paused = false;
     setCurrentTimeInternal(currentTimeInternal(), TimingUpdateOnDemand);
 }
 
 void AnimationPlayer::play()
 {
     if (!playing())
         m_startTime = nullValue();
 
-    setCompositorPending();
+    setPending();
     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;
 }
@@ skipping 19 matching lines @@
 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();
+        setPending();
     }
     if (m_playbackRate < 0) {
         setCurrentTimeInternal(0, TimingUpdateOnDemand);
     } else {
         setCurrentTimeInternal(sourceEnd(), TimingUpdateOnDemand);
     }
     ASSERT(finished());
 }
 
 const AtomicString& AnimationPlayer::interfaceName() const
@@ skipping 24 matching lines @@
     return EventTargetWithInlineData::dispatchEvent(event);
 }
 
 void AnimationPlayer::setPlaybackRate(double playbackRate)
 {
     if (!std::isfinite(playbackRate))
         return;
     if (playbackRate == m_playbackRate)
         return;
 
-    setCompositorPending();
+    setPending();
     if (!finished() && !paused())
         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);
 }
 
 void AnimationPlayer::setOutdated()
 {
     m_outdated = true;
     if (m_timeline)
         m_timeline->setOutdatedAnimationPlayer(this);
 }
 
-bool AnimationPlayer::canStartAnimationOnCompositor()
+void AnimationPlayer::setPending()
 {
-    // FIXME: Need compositor support for playback rate != 1.
-    if (playbackRate() != 1)
-        return false;
-
-    return m_timeline && m_content && m_content->isAnimation() && playing();
-}
-
-bool AnimationPlayer::maybeStartAnimationOnCompositor()
-{
-    if (!canStartAnimationOnCompositor())
-        return false;
-
-    double startTime = timeline()->zeroTime() + startTimeInternal();
-    double timeOffset = 0;
-    if (std::isnan(startTime)) {
-        timeOffset = currentTimeInternal();
-    }
-    return toAnimation(m_content.get())->maybeStartAnimationOnCompositor(startTime, timeOffset);
-}
-
-void AnimationPlayer::setCompositorPending(bool sourceChanged)
-{
-    // FIXME: Animation could notify this directly?
-    if (!hasActiveAnimationsOnCompositor()) {
-        m_compositorState.release();
-    }
-    if (!m_compositorPending) {
-        m_compositorPending = true;
-        if (sourceChanged && m_compositorState)
-            m_compositorState->sourceChanged = true;
-        timeline()->document()->compositorPendingAnimations().add(this);
+    if (!m_pending) {
+        m_pending = true;
+        timeline()->document()->pendingAnimations().add(this);
     }
 }
 
-bool AnimationPlayer::hasActiveAnimationsOnCompositor()
-{
-    if (!m_content || !m_content->isAnimation())
-        return false;
-
-    return toAnimation(m_content.get())->hasActiveAnimationsOnCompositor();
-}
-
-void AnimationPlayer::cancelAnimationOnCompositor()
-{
-    if (hasActiveAnimationsOnCompositor())
-        toAnimation(m_content.get())->cancelAnimationOnCompositor();
-}
-
 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();
@@ skipping 43 matching lines @@
 {
     if (eventType == EventTypeNames::finish)
         UseCounter::count(executionContext(), UseCounter::AnimationPlayerFinishEvent);
     return EventTargetWithInlineData::addEventListener(eventType, listener, useCapture);
 }
 
 void AnimationPlayer::pauseForTesting(double pauseTime)
 {
     RELEASE_ASSERT(!paused());
     setCurrentTimeInternal(pauseTime, TimingUpdateOnDemand);
-    if (hasActiveAnimationsOnCompositor())
-        toAnimation(m_content.get())->pauseAnimationForTestingOnCompositor(currentTimeInternal());
     m_isPausedForTesting = true;
     pause();
 }
 
 } // namespace