Rename Animation -> PrimitiveAnimation

Source/core/page/animation/AnimationBase.cpp

 /*
  * Copyright (C) 2007, 2008, 2009 Apple 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer. 
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 50 matching lines @@
     return bezier.solve(t, solveEpsilon(duration));
 }
 
 static inline double solveStepsFunction(int numSteps, bool stepAtStart, double t)
 {
     if (stepAtStart)
         return min(1.0, (floor(numSteps * t) + 1) / numSteps);
     return floor(numSteps * t) / numSteps;
 }
 
-AnimationBase::AnimationBase(const Animation* transition, RenderObject* renderer, CompositeAnimation* compAnim)
+AnimationBase::AnimationBase(const CSSAnimationData* transition, RenderObject* renderer, CompositeAnimation* compAnim)
     : m_animState(AnimationStateNew)
     , m_isAccelerated(false)
     , m_transformFunctionListValid(false)
     , m_filterFunctionListsMatch(false)
     , m_startTime(0)
     , m_pauseTime(-1)
     , m_requestedStartTime(0)
     , m_totalDuration(-1)
     , m_nextIterationDuration(-1)
     , m_object(renderer)
-    , m_animation(const_cast<Animation*>(transition))
+    , m_animation(const_cast<CSSAnimationData*>(transition))
     , m_compAnim(compAnim)
 {
     // Compute the total duration
     if (m_animation->iterationCount() > 0)
         m_totalDuration = m_animation->duration() * m_animation->iterationCount();
 }
 
 void AnimationBase::setNeedsStyleRecalc(Node* node)
 {
     if (node)
         node->setNeedsStyleRecalc(SyntheticStyleChange);
 }
 
 double AnimationBase::duration() const
 {
     return m_animation->duration();
 }
 
 bool AnimationBase::playStatePlaying() const
 {
     return m_animation->playState() == AnimPlayStatePlaying;
 }
 
-bool AnimationBase::animationsMatch(const Animation* anim) const
+bool AnimationBase::animationsMatch(const CSSAnimationData* anim) const
 {
     return m_animation->animationsMatch(anim);
 }
 
 void AnimationBase::updateStateMachine(AnimStateInput input, double param)
 {
     if (!m_compAnim)
         return;
 
     // If we get AnimationStateInputRestartAnimation then we force a new animation, regardless of state.
@@ skipping 366 matching lines @@
     // concept in AnimationTimeController. So we need to somehow sync the two. Until then, the possible
     // error is small and will probably not be noticeable. Until we fix this, remove the assert.
     // https://bugs.webkit.org/show_bug.cgi?id=52037
     // ASSERT(fractionalTime >= 0);
     if (fractionalTime < 0)
         fractionalTime = 0;
 
     int integralTime = static_cast<int>(fractionalTime);
     const int integralIterationCount = static_cast<int>(m_animation->iterationCount());
     const bool iterationCountHasFractional = m_animation->iterationCount() - integralIterationCount;
-    if (m_animation->iterationCount() != Animation::IterationCountInfinite && !iterationCountHasFractional)
+    if (m_animation->iterationCount() != CSSAnimationData::IterationCountInfinite && !iterationCountHasFractional)
         integralTime = min(integralTime, integralIterationCount - 1);
 
     fractionalTime -= integralTime;
 
-    if (((m_animation->direction() == Animation::AnimationDirectionAlternate) && (integralTime & 1))
-        || ((m_animation->direction() == Animation::AnimationDirectionAlternateReverse) && !(integralTime & 1))
-        || m_animation->direction() == Animation::AnimationDirectionReverse)
+    if (((m_animation->direction() == CSSAnimationData::AnimationDirectionAlternate) && (integralTime & 1))
+        || ((m_animation->direction() == CSSAnimationData::AnimationDirectionAlternateReverse) && !(integralTime & 1))
+        || m_animation->direction() == CSSAnimationData::AnimationDirectionReverse)
         fractionalTime = 1 - fractionalTime;
 
     if (scale != 1 || offset)
         fractionalTime = (fractionalTime - offset) * scale;
 
     return fractionalTime;
 }
 
 double AnimationBase::progress(double scale, double offset, const TimingFunction* tf) const
 {
@@ skipping 100 matching lines @@
         return m_pauseTime - m_startTime;
     if (m_startTime <= 0)
         return 0;
     if (postActive())
         return 1;
 
     return beginAnimationUpdateTime() - m_startTime;
 }
 
 } // namespace WebCore