Rename AnimationEffect to AnimationEffectReadOnly

third_party/WebKit/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 195 matching lines @@
 
 void CSSAnimations::calculateUpdate(const Element* animatingElement, Element& element, const ComputedStyle& style, ComputedStyle* parentStyle, CSSAnimationUpdate& animationUpdate, StyleResolver* resolver)
 {
     calculateCompositorAnimationUpdate(animationUpdate, animatingElement, element, style, parentStyle);
     calculateAnimationUpdate(animationUpdate, animatingElement, element, style, parentStyle, resolver);
     calculateAnimationActiveInterpolations(animationUpdate, animatingElement);
     calculateTransitionUpdate(animationUpdate, animatingElement, style);
     calculateTransitionActiveInterpolations(animationUpdate, animatingElement);
 }
 
-static const KeyframeEffectModelBase* getKeyframeEffectModelBase(const AnimationEffect* effect)
+static const KeyframeEffectModelBase* getKeyframeEffectModelBase(const AnimationEffectReadOnly* effect)
 {
     if (!effect)
         return nullptr;
     const EffectModel* model = nullptr;
     if (effect->isKeyframeEffect())
         model = toKeyframeEffect(effect)->model();
     else if (effect->isInertEffect())
         model = toInertEffect(effect)->model();
     if (!model || !model->isKeyframeEffectModel())
         return nullptr;
@@ skipping 126 matching lines @@
     for (size_t i = 0; i < cancelRunningAnimationFlags.size(); i++) {
         if (cancelRunningAnimationFlags[i]) {
             DCHECK(cssAnimations && !isAnimationStyleChange);
             update.cancelAnimation(i, *cssAnimations->m_runningAnimations[i]->animation);
         }
     }
 }
 
 void CSSAnimations::snapshotCompositorKeyframes(Element& element, CSSAnimationUpdate& update, const ComputedStyle& style, const ComputedStyle* parentStyle)
 {
-    const auto& snapshot = [&element, &style, parentStyle](const AnimationEffect* effect)
+    const auto& snapshot = [&element, &style, parentStyle](const AnimationEffectReadOnly* effect)
     {
         const KeyframeEffectModelBase* keyframeEffect = getKeyframeEffectModelBase(effect);
         if (keyframeEffect && keyframeEffect->needsCompositorKeyframesSnapshot())
             keyframeEffect->snapshotAllCompositorKeyframes(element, style, parentStyle);
     };
 
     ElementAnimations* elementAnimations = element.elementAnimations();
     if (elementAnimations) {
         for (auto& entry : elementAnimations->animations())
             snapshot(entry.key->effect());
@@ skipping 398 matching lines @@
 
 void CSSAnimations::AnimationEventDelegate::maybeDispatch(Document::ListenerType listenerType, const AtomicString& eventName, double elapsedTime)
 {
     if (m_animationTarget->document().hasListenerType(listenerType)) {
         AnimationEvent* event = AnimationEvent::create(eventName, m_name, elapsedTime);
         event->setTarget(eventTarget());
         document().enqueueAnimationFrameEvent(event);
     }
 }
 
-bool CSSAnimations::AnimationEventDelegate::requiresIterationEvents(const AnimationEffect& animationNode)
+bool CSSAnimations::AnimationEventDelegate::requiresIterationEvents(const AnimationEffectReadOnly& animationNode)
 {
     return document().hasListenerType(Document::ANIMATIONITERATION_LISTENER);
 }
 
-void CSSAnimations::AnimationEventDelegate::onEventCondition(const AnimationEffect& animationNode)
+void CSSAnimations::AnimationEventDelegate::onEventCondition(const AnimationEffectReadOnly& animationNode)
 {
-    const AnimationEffect::Phase currentPhase = animationNode.getPhase();
+    const AnimationEffectReadOnly::Phase currentPhase = animationNode.getPhase();
     const double currentIteration = animationNode.currentIteration();
 
     if (m_previousPhase != currentPhase
-        && (currentPhase == AnimationEffect::PhaseActive || currentPhase == AnimationEffect::PhaseAfter)
-        && (m_previousPhase == AnimationEffect::PhaseNone || m_previousPhase == AnimationEffect::PhaseBefore)) {
+        && (currentPhase == AnimationEffectReadOnly::PhaseActive || currentPhase == AnimationEffectReadOnly::PhaseAfter)
+        && (m_previousPhase == AnimationEffectReadOnly::PhaseNone || m_previousPhase == AnimationEffectReadOnly::PhaseBefore)) {
         const double startDelay = animationNode.specifiedTiming().startDelay;
         const double elapsedTime = startDelay < 0 ? -startDelay : 0;
         maybeDispatch(Document::ANIMATIONSTART_LISTENER, EventTypeNames::animationstart, elapsedTime);
     }
 
-    if (currentPhase == AnimationEffect::PhaseActive && m_previousPhase == currentPhase && m_previousIteration != currentIteration) {
+    if (currentPhase == AnimationEffectReadOnly::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.
         DCHECK(!std::isnan(animationNode.specifiedTiming().iterationDuration));
         const double elapsedTime = animationNode.specifiedTiming().iterationDuration * (m_previousIteration + 1);
         maybeDispatch(Document::ANIMATIONITERATION_LISTENER, EventTypeNames::animationiteration, elapsedTime);
     }
 
-    if (currentPhase == AnimationEffect::PhaseAfter && m_previousPhase != AnimationEffect::PhaseAfter)
+    if (currentPhase == AnimationEffectReadOnly::PhaseAfter && m_previousPhase != AnimationEffectReadOnly::PhaseAfter)
         maybeDispatch(Document::ANIMATIONEND_LISTENER, EventTypeNames::animationend, animationNode.activeDurationInternal());
 
     m_previousPhase = currentPhase;
     m_previousIteration = currentIteration;
 }
 
 DEFINE_TRACE(CSSAnimations::AnimationEventDelegate)
 {
     visitor->trace(m_animationTarget);
-    AnimationEffect::EventDelegate::trace(visitor);
+    AnimationEffectReadOnly::EventDelegate::trace(visitor);
 }
 
 EventTarget* CSSAnimations::TransitionEventDelegate::eventTarget() const
 {
     return EventPath::eventTargetRespectingTargetRules(*m_transitionTarget);
 }
 
-void CSSAnimations::TransitionEventDelegate::onEventCondition(const AnimationEffect& animationNode)
+void CSSAnimations::TransitionEventDelegate::onEventCondition(const AnimationEffectReadOnly& animationNode)
 {
-    const AnimationEffect::Phase currentPhase = animationNode.getPhase();
-    if (currentPhase == AnimationEffect::PhaseAfter && currentPhase != m_previousPhase && document().hasListenerType(Document::TRANSITIONEND_LISTENER)) {
+    const AnimationEffectReadOnly::Phase currentPhase = animationNode.getPhase();
+    if (currentPhase == AnimationEffectReadOnly::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(getPseudoId());
         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);
-    AnimationEffect::EventDelegate::trace(visitor);
+    AnimationEffectReadOnly::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.
@@ skipping 38 matching lines @@
 }
 
 DEFINE_TRACE(CSSAnimations)
 {
     visitor->trace(m_transitions);
     visitor->trace(m_pendingUpdate);
     visitor->trace(m_runningAnimations);
 }
 
 } // namespace blink