Web Animations: Update naming to reflect spec changes

Source/core/animation/css/CSSAnimations.cpp

Index: Source/core/animation/css/CSSAnimations.cpp
diff --git a/Source/core/animation/css/CSSAnimations.cpp b/Source/core/animation/css/CSSAnimations.cpp
index cd0af54af26edab4b73203b9cb4e0023057417a1..16837dd36a4ea906883a1fc79a6e9d62b17ac52d 100644
--- a/Source/core/animation/css/CSSAnimations.cpp
+++ b/Source/core/animation/css/CSSAnimations.cpp
@@ -32,7 +32,7 @@
 #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"
@@ -183,19 +183,19 @@ 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;
@@ -257,23 +257,23 @@ void CSSAnimations::calculateAnimationUpdate(CSSAnimationUpdate* update, const E
                     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);
                     }
@@ -292,7 +292,7 @@ void CSSAnimations::calculateAnimationUpdate(CSSAnimationUpdate* update, const E
     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);
     }
 }
 
@@ -313,26 +313,26 @@ void CSSAnimations::maybeApplyPendingUpdate(Element* element)
     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);
     }
@@ -351,22 +351,22 @@ void CSSAnimations::maybeApplyPendingUpdate(Element* element)
         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
@@ -374,30 +374,30 @@ void CSSAnimations::maybeApplyPendingUpdate(Element* element)
     // 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())->downgradeToNormalAnimation();
+        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())->downgradeToNormalAnimation();
         }
     }
 
@@ -409,14 +409,14 @@ void CSSAnimations::maybeApplyPendingUpdate(Element* element)
         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;
 
@@ -440,11 +440,11 @@ void CSSAnimations::maybeApplyPendingUpdate(Element* element)
             }
         }
 
-        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));
@@ -575,9 +575,9 @@ void CSSAnimations::calculateTransitionUpdate(CSSAnimationUpdate* update, const
             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);
             }
         }
@@ -587,13 +587,13 @@ void CSSAnimations::calculateTransitionUpdate(CSSAnimationUpdate* update, const
 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();
@@ -606,19 +606,19 @@ void CSSAnimations::calculateAnimationActiveInterpolations(CSSAnimationUpdate* u
     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);
 }
 
@@ -629,23 +629,23 @@ void CSSAnimations::calculateTransitionActiveInterpolations(CSSAnimationUpdate*
 
     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.
@@ -670,25 +670,25 @@ void CSSAnimations::AnimationEventDelegate::maybeDispatch(Document::ListenerType
     }
 }
 
-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
@@ -698,7 +698,7 @@ void CSSAnimations::AnimationEventDelegate::onEventCondition(const AnimationNode
         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;
@@ -708,7 +708,7 @@ void CSSAnimations::AnimationEventDelegate::onEventCondition(const AnimationNode
 DEFINE_TRACE(CSSAnimations::AnimationEventDelegate)
 {
     visitor->trace(m_animationTarget);
-    AnimationNode::EventDelegate::trace(visitor);
+    AnimationEffect::EventDelegate::trace(visitor);
 }
 
 EventTarget* CSSAnimations::TransitionEventDelegate::eventTarget() const
@@ -716,10 +716,10 @@ 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;
@@ -736,7 +736,7 @@ void CSSAnimations::TransitionEventDelegate::onEventCondition(const AnimationNod
 DEFINE_TRACE(CSSAnimations::TransitionEventDelegate)
 {
     visitor->trace(m_transitionTarget);
-    AnimationNode::EventDelegate::trace(visitor);
+    AnimationEffect::EventDelegate::trace(visitor);
 }
 
 const StylePropertyShorthand& CSSAnimations::propertiesForTransitionAll()
@@ -761,7 +761,7 @@ const StylePropertyShorthand& CSSAnimations::propertiesForTransitionAll()
     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)
 {
@@ -804,7 +804,7 @@ DEFINE_TRACE(CSSAnimationUpdate)
     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