Web Animations: Update naming to reflect spec changes

Source/core/animation/css/CSSAnimations.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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/animation/css/CSSAnimations.h"
 
 #include "core/StylePropertyShorthand.h"
-#include "core/animation/AnimationPlayer.h"
+#include "core/animation/Animation.h"
 #include "core/animation/AnimationTimeline.h"
 #include "core/animation/CompositorAnimations.h"
 #include "core/animation/DeferredLegacyStyleInterpolation.h"
 #include "core/animation/ElementAnimations.h"
 #include "core/animation/Interpolation.h"
 #include "core/animation/KeyframeEffectModel.h"
 #include "core/animation/css/CSSAnimatableValueFactory.h"
 #include "core/animation/css/CSSPropertyEquality.h"
 #include "core/css/CSSKeyframeRule.h"
 #include "core/css/CSSPropertyMetadata.h"
@@ skipping 130 matching lines @@
     effect->forceConversionsToAnimatableValues(element, style);
     return effect;
 }
 
 } // namespace
 
 CSSAnimations::CSSAnimations()
 {
 }
 
-const AtomicString CSSAnimations::getAnimationNameForInspector(const AnimationPlayer& player)
+const AtomicString CSSAnimations::getAnimationNameForInspector(const Animation& animation)
 {
     for (const auto& it : m_animations) {
-        if (it.value->player->sequenceNumber() == player.sequenceNumber())
+        if (it.value->animation->sequenceNumber() == animation.sequenceNumber())
             return it.key;
     }
     return nullAtom;
 }
 
-bool CSSAnimations::isTransitionAnimationForInspector(const AnimationPlayer& player) const
+bool CSSAnimations::isTransitionAnimationForInspector(const Animation& animation) const
 {
     for (const auto& it : m_transitions) {
-        if (it.value.player->sequenceNumber() == player.sequenceNumber())
+        if (it.value.animation->sequenceNumber() == animation.sequenceNumber())
             return true;
     }
     return false;
 }
 
 PassOwnPtrWillBeRawPtr<CSSAnimationUpdate> CSSAnimations::calculateUpdate(const Element* animatingElement, Element& element, const ComputedStyle& style, ComputedStyle* parentStyle, StyleResolver* resolver)
 {
     OwnPtrWillBeRawPtr<CSSAnimationUpdate> update = adoptPtrWillBeNoop(new CSSAnimationUpdate());
     calculateAnimationUpdate(update.get(), animatingElement, element, style, parentStyle, resolver);
     calculateAnimationActiveInterpolations(update.get(), animatingElement, element.document().timeline().currentTimeInternal());
@@ skipping 41 matching lines @@
             RefPtrWillBeRawPtr<StyleRuleKeyframes> keyframesRule = resolver->findKeyframesRule(elementForScoping, animationName);
             if (!keyframesRule)
                 continue; // Cancel the animation if there's no style rule for it.
 
             if (cssAnimations) {
                 AnimationMap::const_iterator existing(cssAnimations->m_animations.find(animationName));
                 if (existing != cssAnimations->m_animations.end()) {
                     inactive.remove(animationName);
 
                     const RunningAnimation* runningAnimation = existing->value.get();
-                    AnimationPlayer* player = runningAnimation->player.get();
+                    Animation* animation = runningAnimation->animation.get();
 
                     if (keyframesRule != runningAnimation->styleRule || keyframesRule->version() != runningAnimation->styleRuleVersion || runningAnimation->specifiedTiming != specifiedTiming) {
                         ASSERT(!isAnimationStyleChange);
-                        update->updateAnimation(animationName, player, InertAnimation::create(
+                        update->updateAnimation(animationName, animation, InertAnimation::create(
                             createKeyframeEffect(resolver, animatingElement, element, &style, parentStyle, animationName, keyframeTimingFunction.get()),
-                            timing, isPaused, player->unlimitedCurrentTimeInternal()), specifiedTiming, keyframesRule);
-                    } else if (!isAnimationStyleChange && player->source() && player->source()->isAnimation()) {
-                        AnimationEffect* effect = toAnimation(player->source())->effect();
+                            timing, isPaused, animation->unlimitedCurrentTimeInternal()), specifiedTiming, keyframesRule);
+                    } else if (!isAnimationStyleChange && animation->source() && animation->source()->isAnimation()) {
+                        EffectModel* effect = toKeyframeEffect(animation->source())->effect();
                         if (effect && effect->isKeyframeEffectModel()) {
                             KeyframeEffectModelBase* keyframeEffect = toKeyframeEffectModelBase(effect);
                             if (keyframeEffect->hasSyntheticKeyframes())
-                                update->updateAnimationStyle(player, keyframeEffect, animatingElement->layoutObject(), style);
+                                update->updateAnimationStyle(animation, keyframeEffect, animatingElement->layoutObject(), style);
                         }
                     }
 
-                    if (isPaused != player->paused()) {
+                    if (isPaused != animation->paused()) {
                         ASSERT(!isAnimationStyleChange);
                         update->toggleAnimationPaused(animationName);
                     }
 
                     continue;
                 }
             }
 
             ASSERT(!isAnimationStyleChange);
             update->startAnimation(animationName, InertAnimation::create(
                 createKeyframeEffect(resolver, animatingElement, element, &style, parentStyle, animationName, keyframeTimingFunction.get()),
                 timing, isPaused, 0), specifiedTiming, keyframesRule);
         }
     }
 
     ASSERT(inactive.isEmpty() || cssAnimations);
     for (const AtomicString& animationName : inactive) {
         ASSERT(!isAnimationStyleChange);
-        update->cancelAnimation(animationName, *cssAnimations->m_animations.get(animationName)->player);
+        update->cancelAnimation(animationName, *cssAnimations->m_animations.get(animationName)->animation);
     }
 }
 
 void CSSAnimations::maybeApplyPendingUpdate(Element* element)
 {
     if (!m_pendingUpdate) {
         m_previousActiveInterpolationsForAnimations.clear();
         return;
     }
 
     OwnPtrWillBeRawPtr<CSSAnimationUpdate> update = m_pendingUpdate.release();
 
     m_previousActiveInterpolationsForAnimations.swap(update->activeInterpolationsForAnimations());
 
     // FIXME: cancelling, pausing, unpausing animations all query compositingState, which is not necessarily up to date here
     // since we call this from recalc style.
     // https://code.google.com/p/chromium/issues/detail?id=339847
     DisableCompositingQueryAsserts disabler;
 
     for (const AtomicString& animationName : update->cancelledAnimationNames()) {
-        RefPtrWillBeRawPtr<AnimationPlayer> player = m_animations.take(animationName)->player;
-        player->cancel();
-        player->update(TimingUpdateOnDemand);
+        RefPtrWillBeRawPtr<Animation> animation = m_animations.take(animationName)->animation;
+        animation->cancel();
+        animation->update(TimingUpdateOnDemand);
     }
 
     for (const AtomicString& animationName : update->animationsWithPauseToggled()) {
-        AnimationPlayer* player = m_animations.get(animationName)->player.get();
-        if (player->paused())
-            player->unpause();
+        Animation* animation = m_animations.get(animationName)->animation.get();
+        if (animation->paused())
+            animation->unpause();
         else
-            player->pause();
-        if (player->outdated())
-            player->update(TimingUpdateOnDemand);
+            animation->pause();
+        if (animation->outdated())
+            animation->update(TimingUpdateOnDemand);
     }
 
     for (const auto& entry : update->animationsWithUpdates()) {
-        Animation* animation = toAnimation(entry.player->source());
+        KeyframeEffect* effect = toKeyframeEffect(entry.animation->source());
 
-        animation->setEffect(entry.animation->effect());
-        animation->updateSpecifiedTiming(entry.animation->specifiedTiming());
+        effect->setEffect(entry.effect->effect());
+        effect->updateSpecifiedTiming(entry.effect->specifiedTiming());
 
         m_animations.find(entry.name)->value->update(entry);
     }
 
     for (const auto& styleUpdate : update->animationsWithStyleUpdates()) {
         styleUpdate.effect->forEachInterpolation([](Interpolation& interpolation) {
             if (interpolation.isStyleInterpolation() && toStyleInterpolation(interpolation).isDeferredLegacyStyleInterpolation())
                 toDeferredLegacyStyleInterpolation(toStyleInterpolation(interpolation)).underlyingStyleChanged();
         });
 
         bool updated = false;
         if (styleUpdate.snapshot.opacity)
             updated |= styleUpdate.effect->updateNeutralKeyframeAnimatableValues(CSSPropertyOpacity, styleUpdate.snapshot.opacity);
         if (styleUpdate.snapshot.transform)
             updated |= styleUpdate.effect->updateNeutralKeyframeAnimatableValues(CSSPropertyTransform, styleUpdate.snapshot.transform);
         if (styleUpdate.snapshot.webkitFilter)
             updated |= styleUpdate.effect->updateNeutralKeyframeAnimatableValues(CSSPropertyWebkitFilter, styleUpdate.snapshot.webkitFilter);
         if (updated) {
-            styleUpdate.player->setOutdated();
-            styleUpdate.player->setCompositorPending(true);
+            styleUpdate.animation->setOutdated();
+            styleUpdate.animation->setCompositorPending(true);
         }
     }
 
     for (const auto& entry : update->newAnimations()) {
-        const InertAnimation* inertAnimation = entry.animation.get();
+        const InertAnimation* inertAnimation = entry.effect.get();
         OwnPtrWillBeRawPtr<AnimationEventDelegate> eventDelegate = adoptPtrWillBeNoop(new AnimationEventDelegate(element, entry.name));
-        RefPtrWillBeRawPtr<Animation> animation = Animation::create(element, inertAnimation->effect(), inertAnimation->specifiedTiming(), Animation::DefaultPriority, eventDelegate.release());
-        animation->setName(inertAnimation->name());
-        RefPtrWillBeRawPtr<AnimationPlayer> player = element->document().timeline().play(animation.get());
+        RefPtrWillBeRawPtr<KeyframeEffect> effect = KeyframeEffect::create(element, inertAnimation->effect(), inertAnimation->specifiedTiming(), KeyframeEffect::DefaultPriority, eventDelegate.release());
+        effect->setName(inertAnimation->name());
+        RefPtrWillBeRawPtr<Animation> animation = element->document().timeline().play(effect.get());
         if (inertAnimation->paused())
-            player->pause();
-        player->update(TimingUpdateOnDemand);
+            animation->pause();
+        animation->update(TimingUpdateOnDemand);
 
-        m_animations.set(entry.name, adoptRefWillBeNoop(new RunningAnimation(player, entry)));
+        m_animations.set(entry.name, adoptRefWillBeNoop(new RunningAnimation(animation, entry)));
     }
 
     // Transitions that are run on the compositor only update main-thread state
     // lazily. However, we need the new state to know what the from state shoud
     // be when transitions are retargeted. Instead of triggering complete style
     // recalculation, we find these cases by searching for new transitions that
     // have matching cancelled animation property IDs on the compositor.
-    WillBeHeapHashMap<CSSPropertyID, std::pair<RefPtrWillBeMember<Animation>, double>> retargetedCompositorTransitions;
+    WillBeHeapHashMap<CSSPropertyID, std::pair<RefPtrWillBeMember<KeyframeEffect>, double>> retargetedCompositorTransitions;
     for (CSSPropertyID id : update->cancelledTransitions()) {
         ASSERT(m_transitions.contains(id));
 
-        RefPtrWillBeRawPtr<AnimationPlayer> player = m_transitions.take(id).player;
-        Animation* animation = toAnimation(player->source());
-        if (animation->hasActiveAnimationsOnCompositor(id) && update->newTransitions().find(id) != update->newTransitions().end() && !player->limited())
-            retargetedCompositorTransitions.add(id, std::pair<RefPtrWillBeMember<Animation>, double>(animation, player->startTimeInternal()));
-        player->cancel();
+        RefPtrWillBeRawPtr<Animation> animation = m_transitions.take(id).animation;
+        KeyframeEffect* effect = toKeyframeEffect(animation->source());
+        if (effect->hasActiveAnimationsOnCompositor(id) && update->newTransitions().find(id) != update->newTransitions().end() && !animation->limited())
+            retargetedCompositorTransitions.add(id, std::pair<RefPtrWillBeMember<KeyframeEffect>, double>(effect, animation->startTimeInternal()));
+        animation->cancel();
         // after cancelation, transitions must be downgraded or they'll fail
         // to be considered when retriggering themselves. This can happen if
-        // the transition is captured through getAnimationPlayers then played.
-        if (player->source() && player->source()->isAnimation())
-            toAnimation(player->source())->downgradeToNormalAnimation();
-        player->update(TimingUpdateOnDemand);
+        // the transition is captured through getAnimations then played.
+        if (animation->source() && animation->source()->isAnimation())
+            toKeyframeEffect(animation->source())->downgradeToNormal();
+        animation->update(TimingUpdateOnDemand);
     }
 
     for (CSSPropertyID id : update->finishedTransitions()) {
         // This transition can also be cancelled and finished at the same time
         if (m_transitions.contains(id)) {
-            RefPtrWillBeRawPtr<AnimationPlayer> player = m_transitions.take(id).player;
+            RefPtrWillBeRawPtr<Animation> animation = m_transitions.take(id).animation;
             // Transition must be downgraded
-            if (player->source() && player->source()->isAnimation())
-                toAnimation(player->source())->downgradeToNormalAnimation();
+            if (animation->source() && animation->source()->isAnimation())
+                toKeyframeEffect(animation->source())->downgradeToNormal();
         }
     }
 
     for (const auto& entry : update->newTransitions()) {
         const CSSAnimationUpdate::NewTransition& newTransition = entry.value;
 
         RunningTransition runningTransition;
         runningTransition.from = newTransition.from;
         runningTransition.to = newTransition.to;
 
         CSSPropertyID id = newTransition.id;
-        InertAnimation* inertAnimation = newTransition.animation.get();
+        InertAnimation* inertAnimation = newTransition.effect.get();
         OwnPtrWillBeRawPtr<TransitionEventDelegate> eventDelegate = adoptPtrWillBeNoop(new TransitionEventDelegate(element, newTransition.eventId));
 
-        RefPtrWillBeRawPtr<AnimationEffect> effect = inertAnimation->effect();
+        RefPtrWillBeRawPtr<EffectModel> effect = inertAnimation->effect();
 
         if (retargetedCompositorTransitions.contains(id)) {
-            const std::pair<RefPtrWillBeMember<Animation>, double>& oldTransition = retargetedCompositorTransitions.get(id);
-            RefPtrWillBeRawPtr<Animation> oldAnimation = oldTransition.first;
+            const std::pair<RefPtrWillBeMember<KeyframeEffect>, double>& oldTransition = retargetedCompositorTransitions.get(id);
+            RefPtrWillBeRawPtr<KeyframeEffect> oldAnimation = oldTransition.first;
             double oldStartTime = oldTransition.second;
             double inheritedTime = isNull(oldStartTime) ? 0 : element->document().timeline().currentTimeInternal() - oldStartTime;
 
             AnimatableValueKeyframeEffectModel* oldEffect = toAnimatableValueKeyframeEffectModel(inertAnimation->effect());
             const KeyframeVector& frames = oldEffect->getFrames();
 
             AnimatableValueKeyframeVector newFrames;
             newFrames.append(toAnimatableValueKeyframe(frames[0]->clone().get()));
             newFrames.append(toAnimatableValueKeyframe(frames[1]->clone().get()));
             newFrames.append(toAnimatableValueKeyframe(frames[2]->clone().get()));
             newFrames[0]->clearPropertyValue(id);
             newFrames[1]->clearPropertyValue(id);
 
             RefPtrWillBeRawPtr<InertAnimation> inertAnimationForSampling = InertAnimation::create(oldAnimation->effect(), oldAnimation->specifiedTiming(), false, inheritedTime);
             OwnPtrWillBeRawPtr<WillBeHeapVector<RefPtrWillBeMember<Interpolation>>> sample = nullptr;
             inertAnimationForSampling->sample(sample);
             if (sample && sample->size() == 1) {
                 newFrames[0]->setPropertyValue(id, toLegacyStyleInterpolation(sample->at(0).get())->currentValue());
                 newFrames[1]->setPropertyValue(id, toLegacyStyleInterpolation(sample->at(0).get())->currentValue());
                 effect = AnimatableValueKeyframeEffectModel::create(newFrames);
             }
         }
 
-        RefPtrWillBeRawPtr<Animation> transition = Animation::create(element, effect, inertAnimation->specifiedTiming(), Animation::TransitionPriority, eventDelegate.release());
+        RefPtrWillBeRawPtr<KeyframeEffect> transition = KeyframeEffect::create(element, effect, inertAnimation->specifiedTiming(), KeyframeEffect::TransitionPriority, eventDelegate.release());
         transition->setName(inertAnimation->name());
-        RefPtrWillBeRawPtr<AnimationPlayer> player = element->document().timeline().play(transition.get());
-        player->update(TimingUpdateOnDemand);
-        runningTransition.player = player;
+        RefPtrWillBeRawPtr<Animation> animation = element->document().timeline().play(transition.get());
+        animation->update(TimingUpdateOnDemand);
+        runningTransition.animation = animation;
         m_transitions.set(id, runningTransition);
         ASSERT(id != CSSPropertyInvalid);
         Platform::current()->histogramSparse("WebCore.Animation.CSSProperties", UseCounter::mapCSSPropertyIdToCSSSampleIdForHistogram(id));
     }
 }
 
 void CSSAnimations::calculateTransitionUpdateForProperty(CSSPropertyID id, CSSPropertyID eventId, const CSSTransitionData& transitionData, size_t transitionIndex, const ComputedStyle& oldStyle, const ComputedStyle& style, const TransitionMap* activeTransitions, CSSAnimationUpdate* update, const Element* element)
 {
     RefPtrWillBeRawPtr<AnimatableValue> to = nullptr;
     if (activeTransitions) {
@@ skipping 110 matching lines @@
                 }
             }
         }
     }
 
     if (activeTransitions) {
         for (const auto& entry : *activeTransitions) {
             CSSPropertyID id = entry.key;
             if (!anyTransitionHadTransitionAll && !animationStyleRecalc && !listedProperties.get(id)) {
                 // TODO: Figure out why this fails on Chrome OS login page. crbug.com/365507
-                // ASSERT(player.playStateInternal() == AnimationPlayer::Finished || !(elementAnimations && elementAnimations->isAnimationStyleChange()));
+                // ASSERT(animation.playStateInternal() == Animation::Finished || !(elementAnimations && elementAnimations->isAnimationStyleChange()));
                 update->cancelTransition(id);
-            } else if (entry.value.player->finishedInternal()) {
+            } else if (entry.value.animation->finishedInternal()) {
                 update->finishTransition(id);
             }
         }
     }
 }
 
 void CSSAnimations::cancel()
 {
     for (const auto& entry : m_animations) {
-        entry.value->player->cancel();
-        entry.value->player->update(TimingUpdateOnDemand);
+        entry.value->animation->cancel();
+        entry.value->animation->update(TimingUpdateOnDemand);
     }
 
     for (const auto& entry : m_transitions) {
-        entry.value.player->cancel();
-        entry.value.player->update(TimingUpdateOnDemand);
+        entry.value.animation->cancel();
+        entry.value.animation->update(TimingUpdateOnDemand);
     }
 
     m_animations.clear();
     m_transitions.clear();
     m_pendingUpdate = nullptr;
 }
 
 void CSSAnimations::calculateAnimationActiveInterpolations(CSSAnimationUpdate* update, const Element* animatingElement, double timelineCurrentTime)
 {
     ElementAnimations* elementAnimations = animatingElement ? animatingElement->elementAnimations() : nullptr;
     AnimationStack* animationStack = elementAnimations ? &elementAnimations->defaultStack() : nullptr;
 
-    if (update->newAnimations().isEmpty() && update->suppressedAnimationAnimationPlayers().isEmpty()) {
-        ActiveInterpolationMap activeInterpolationsForAnimations(AnimationStack::activeInterpolations(animationStack, 0, 0, Animation::DefaultPriority, timelineCurrentTime));
+    if (update->newAnimations().isEmpty() && update->suppressedAnimationAnimations().isEmpty()) {
+        ActiveInterpolationMap activeInterpolationsForAnimations(AnimationStack::activeInterpolations(animationStack, 0, 0, KeyframeEffect::DefaultPriority, timelineCurrentTime));
         update->adoptActiveInterpolationsForAnimations(activeInterpolationsForAnimations);
         return;
     }
 
-    WillBeHeapVector<RawPtrWillBeMember<InertAnimation>> newAnimations;
+    WillBeHeapVector<RawPtrWillBeMember<InertAnimation>> newEffects;
     for (const auto& newAnimation : update->newAnimations())
-        newAnimations.append(newAnimation.animation.get());
+        newEffects.append(newAnimation.effect.get());
     for (const auto& updatedAnimation : update->animationsWithUpdates())
-        newAnimations.append(updatedAnimation.animation.get()); // Animations with updates use a temporary InertAnimation for the current frame.
+        newEffects.append(updatedAnimation.effect.get()); // Animations with updates use a temporary InertAnimation for the current frame.
 
-    ActiveInterpolationMap activeInterpolationsForAnimations(AnimationStack::activeInterpolations(animationStack, &newAnimations, &update->suppressedAnimationAnimationPlayers(), Animation::DefaultPriority, timelineCurrentTime));
+    ActiveInterpolationMap activeInterpolationsForAnimations(AnimationStack::activeInterpolations(animationStack, &newEffects, &update->suppressedAnimationAnimations(), KeyframeEffect::DefaultPriority, timelineCurrentTime));
     update->adoptActiveInterpolationsForAnimations(activeInterpolationsForAnimations);
 }
 
 void CSSAnimations::calculateTransitionActiveInterpolations(CSSAnimationUpdate* update, const Element* animatingElement, double timelineCurrentTime)
 {
     ElementAnimations* elementAnimations = animatingElement ? animatingElement->elementAnimations() : nullptr;
     AnimationStack* animationStack = elementAnimations ? &elementAnimations->defaultStack() : nullptr;
 
     ActiveInterpolationMap activeInterpolationsForTransitions;
     if (update->newTransitions().isEmpty() && update->cancelledTransitions().isEmpty()) {
-        activeInterpolationsForTransitions = AnimationStack::activeInterpolations(animationStack, 0, 0, Animation::TransitionPriority, timelineCurrentTime);
+        activeInterpolationsForTransitions = AnimationStack::activeInterpolations(animationStack, 0, 0, KeyframeEffect::TransitionPriority, timelineCurrentTime);
     } else {
         WillBeHeapVector<RawPtrWillBeMember<InertAnimation>> newTransitions;
         for (const auto& entry : update->newTransitions())
-            newTransitions.append(entry.value.animation.get());
+            newTransitions.append(entry.value.effect.get());
 
-        WillBeHeapHashSet<RawPtrWillBeMember<const AnimationPlayer>> cancelledAnimationPlayers;
+        WillBeHeapHashSet<RawPtrWillBeMember<const Animation>> cancelledAnimations;
         if (!update->cancelledTransitions().isEmpty()) {
             ASSERT(elementAnimations);
             const TransitionMap& transitionMap = elementAnimations->cssAnimations().m_transitions;
             for (CSSPropertyID id : update->cancelledTransitions()) {
                 ASSERT(transitionMap.contains(id));
-                cancelledAnimationPlayers.add(transitionMap.get(id).player.get());
+                cancelledAnimations.add(transitionMap.get(id).animation.get());
             }
         }
 
-        activeInterpolationsForTransitions = AnimationStack::activeInterpolations(animationStack, &newTransitions, &cancelledAnimationPlayers, Animation::TransitionPriority, timelineCurrentTime);
+        activeInterpolationsForTransitions = AnimationStack::activeInterpolations(animationStack, &newTransitions, &cancelledAnimations, KeyframeEffect::TransitionPriority, timelineCurrentTime);
     }
 
     // Properties being animated by animations don't get values from transitions applied.
     if (!update->activeInterpolationsForAnimations().isEmpty() && !activeInterpolationsForTransitions.isEmpty()) {
         for (const auto& entry : update->activeInterpolationsForAnimations())
             activeInterpolationsForTransitions.remove(entry.key);
     }
     update->adoptActiveInterpolationsForTransitions(activeInterpolationsForTransitions);
 }
 
 EventTarget* CSSAnimations::AnimationEventDelegate::eventTarget() const
 {
     return EventPath::eventTargetRespectingTargetRules(*m_animationTarget);
 }
 
 void CSSAnimations::AnimationEventDelegate::maybeDispatch(Document::ListenerType listenerType, const AtomicString& eventName, double elapsedTime)
 {
     if (m_animationTarget->document().hasListenerType(listenerType)) {
         RefPtrWillBeRawPtr<AnimationEvent> event = AnimationEvent::create(eventName, m_name, elapsedTime);
         event->setTarget(eventTarget());
         document().enqueueAnimationFrameEvent(event);
     }
 }
 
-bool CSSAnimations::AnimationEventDelegate::requiresIterationEvents(const AnimationNode& animationNode)
+bool CSSAnimations::AnimationEventDelegate::requiresIterationEvents(const AnimationEffect& animationNode)
 {
     return document().hasListenerType(Document::ANIMATIONITERATION_LISTENER);
 }
 
-void CSSAnimations::AnimationEventDelegate::onEventCondition(const AnimationNode& animationNode)
+void CSSAnimations::AnimationEventDelegate::onEventCondition(const AnimationEffect& animationNode)
 {
-    const AnimationNode::Phase currentPhase = animationNode.phase();
+    const AnimationEffect::Phase currentPhase = animationNode.phase();
     const double currentIteration = animationNode.currentIteration();
 
     if (m_previousPhase != currentPhase
-        && (currentPhase == AnimationNode::PhaseActive || currentPhase == AnimationNode::PhaseAfter)
-        && (m_previousPhase == AnimationNode::PhaseNone || m_previousPhase == AnimationNode::PhaseBefore)) {
+        && (currentPhase == AnimationEffect::PhaseActive || currentPhase == AnimationEffect::PhaseAfter)
+        && (m_previousPhase == AnimationEffect::PhaseNone || m_previousPhase == AnimationEffect::PhaseBefore)) {
         const double startDelay = animationNode.specifiedTiming().startDelay;
         const double elapsedTime = startDelay < 0 ? -startDelay : 0;
         maybeDispatch(Document::ANIMATIONSTART_LISTENER, EventTypeNames::animationstart, elapsedTime);
     }
 
-    if (currentPhase == AnimationNode::PhaseActive && m_previousPhase == currentPhase && m_previousIteration != currentIteration) {
+    if (currentPhase == AnimationEffect::PhaseActive && m_previousPhase == currentPhase && m_previousIteration != currentIteration) {
         // We fire only a single event for all iterations thast terminate
         // between a single pair of samples. See http://crbug.com/275263. For
         // compatibility with the existing implementation, this event uses
         // the elapsedTime for the first iteration in question.
         ASSERT(!std::isnan(animationNode.specifiedTiming().iterationDuration));
         const double elapsedTime = animationNode.specifiedTiming().iterationDuration * (m_previousIteration + 1);
         maybeDispatch(Document::ANIMATIONITERATION_LISTENER, EventTypeNames::animationiteration, elapsedTime);
     }
 
-    if (currentPhase == AnimationNode::PhaseAfter && m_previousPhase != AnimationNode::PhaseAfter)
+    if (currentPhase == AnimationEffect::PhaseAfter && m_previousPhase != AnimationEffect::PhaseAfter)
         maybeDispatch(Document::ANIMATIONEND_LISTENER, EventTypeNames::animationend, animationNode.activeDurationInternal());
 
     m_previousPhase = currentPhase;
     m_previousIteration = currentIteration;
 }
 
 DEFINE_TRACE(CSSAnimations::AnimationEventDelegate)
 {
     visitor->trace(m_animationTarget);
-    AnimationNode::EventDelegate::trace(visitor);
+    AnimationEffect::EventDelegate::trace(visitor);
 }
 
 EventTarget* CSSAnimations::TransitionEventDelegate::eventTarget() const
 {
     return EventPath::eventTargetRespectingTargetRules(*m_transitionTarget);
 }
 
-void CSSAnimations::TransitionEventDelegate::onEventCondition(const AnimationNode& animationNode)
+void CSSAnimations::TransitionEventDelegate::onEventCondition(const AnimationEffect& animationNode)
 {
-    const AnimationNode::Phase currentPhase = animationNode.phase();
-    if (currentPhase == AnimationNode::PhaseAfter && currentPhase != m_previousPhase && document().hasListenerType(Document::TRANSITIONEND_LISTENER)) {
+    const AnimationEffect::Phase currentPhase = animationNode.phase();
+    if (currentPhase == AnimationEffect::PhaseAfter && currentPhase != m_previousPhase && document().hasListenerType(Document::TRANSITIONEND_LISTENER)) {
         String propertyName = getPropertyNameString(m_property);
         const Timing& timing = animationNode.specifiedTiming();
         double elapsedTime = timing.iterationDuration;
         const AtomicString& eventType = EventTypeNames::transitionend;
         String pseudoElement = PseudoElement::pseudoElementNameForEvents(pseudoId());
         RefPtrWillBeRawPtr<TransitionEvent> event = TransitionEvent::create(eventType, propertyName, elapsedTime, pseudoElement);
         event->setTarget(eventTarget());
         document().enqueueAnimationFrameEvent(event);
     }
 
     m_previousPhase = currentPhase;
 }
 
 DEFINE_TRACE(CSSAnimations::TransitionEventDelegate)
 {
     visitor->trace(m_transitionTarget);
-    AnimationNode::EventDelegate::trace(visitor);
+    AnimationEffect::EventDelegate::trace(visitor);
 }
 
 const StylePropertyShorthand& CSSAnimations::propertiesForTransitionAll()
 {
     DEFINE_STATIC_LOCAL(Vector<CSSPropertyID>, properties, ());
     DEFINE_STATIC_LOCAL(StylePropertyShorthand, propertyShorthand, ());
     if (properties.isEmpty()) {
         for (int i = firstCSSProperty; i < lastCSSProperty; ++i) {
             CSSPropertyID id = convertToCSSPropertyID(i);
             // Avoid creating overlapping transitions with perspective-origin and transition-origin.
             if (id == CSSPropertyWebkitPerspectiveOriginX
                 || id == CSSPropertyWebkitPerspectiveOriginY
                 || id == CSSPropertyWebkitTransformOriginX
                 || id == CSSPropertyWebkitTransformOriginY
                 || id == CSSPropertyWebkitTransformOriginZ)
                 continue;
             if (CSSPropertyMetadata::isAnimatableProperty(id))
                 properties.append(id);
         }
         propertyShorthand = StylePropertyShorthand(CSSPropertyInvalid, properties.begin(), properties.size());
     }
     return propertyShorthand;
 }
 
-// Animation properties are not allowed to be affected by Web Animations.
+// KeyframeEffect properties are not allowed to be affected by Web Animations.
 // http://dev.w3.org/fxtf/web-animations/#not-animatable
 bool CSSAnimations::isAllowedAnimation(CSSPropertyID property)
 {
     switch (property) {
     case CSSPropertyAnimation:
     case CSSPropertyAnimationDelay:
     case CSSPropertyAnimationDirection:
     case CSSPropertyAnimationDuration:
     case CSSPropertyAnimationFillMode:
     case CSSPropertyAnimationIterationCount:
@@ skipping 22 matching lines @@
 #endif
 }
 
 DEFINE_TRACE(CSSAnimationUpdate)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_newTransitions);
     visitor->trace(m_activeInterpolationsForAnimations);
     visitor->trace(m_activeInterpolationsForTransitions);
     visitor->trace(m_newAnimations);
-    visitor->trace(m_suppressedAnimationPlayers);
+    visitor->trace(m_suppressedAnimations);
     visitor->trace(m_animationsWithUpdates);
     visitor->trace(m_animationsWithStyleUpdates);
 #endif
 }
 
 } // namespace blink