Rename Animation -> PrimitiveAnimation

Source/core/platform/graphics/GraphicsLayerAnimation.cpp

 /*
  Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.
 
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 55 matching lines @@
             if (progress > 0.5)
                 result.operations().append(toOp ? toOp : identityOp);
             else
                 result.operations().append(fromOp ? fromOp : identityOp);
         }
     }
 
     return result;
 }
 
-static bool shouldReverseAnimationValue(Animation::AnimationDirection direction, int loopCount)
+static bool shouldReverseAnimationValue(PrimitiveAnimation::AnimationDirection direction, int loopCount)
 {
-    if (((direction == Animation::AnimationDirectionAlternate) && (loopCount & 1))
-        || ((direction == Animation::AnimationDirectionAlternateReverse) && !(loopCount & 1))
-        || direction == Animation::AnimationDirectionReverse)
+    if (((direction == PrimitiveAnimation::AnimationDirectionAlternate) && (loopCount & 1))
+        || ((direction == PrimitiveAnimation::AnimationDirectionAlternateReverse) && !(loopCount & 1))
+        || direction == PrimitiveAnimation::AnimationDirectionReverse)
         return true;
     return false;
 }
 
-static double normalizedAnimationValue(double runningTime, double duration, Animation::AnimationDirection direction, double iterationCount)
+static double normalizedAnimationValue(double runningTime, double duration, PrimitiveAnimation::AnimationDirection direction, double iterationCount)
 {
     if (!duration)
         return 0;
 
     const int loopCount = runningTime / duration;
     const double lastFullLoop = duration * double(loopCount);
     const double remainder = runningTime - lastFullLoop;
     // Ignore remainder when we've reached the end of animation.
     const double normalized = (loopCount == iterationCount) ? 1.0 : (remainder / duration);
 
     return shouldReverseAnimationValue(direction, loopCount) ? 1 - normalized : normalized;
 }
 
-static double normalizedAnimationValueForFillsForwards(double iterationCount, Animation::AnimationDirection direction)
+static double normalizedAnimationValueForFillsForwards(double iterationCount, PrimitiveAnimation::AnimationDirection direction)
 {
-    if (direction == Animation::AnimationDirectionNormal)
+    if (direction == PrimitiveAnimation::AnimationDirectionNormal)
         return 1;
-    if (direction == Animation::AnimationDirectionReverse)
+    if (direction == PrimitiveAnimation::AnimationDirectionReverse)
         return 0;
     return shouldReverseAnimationValue(direction, iterationCount) ? 1 : 0;
 }
 
 static float applyOpacityAnimation(float fromOpacity, float toOpacity, double progress)
 {
     // Optimization: special case the edge values (0 and 1).
     if (progress == 1.0)
         return toOpacity;
 
@@ skipping 79 matching lines @@
         return matrix;
     }
 
     // Normal animation with a matching operation list.
     TransformOperations blended(*to);
     for (size_t i = 0; i < blended.operations().size(); ++i)
         blended.operations()[i]->blend(from->at(i), progress, !from->at(i))->apply(matrix, boxSize);
     return matrix;
 }
 
-static const TimingFunction* timingFunctionForAnimationValue(const AnimationValue* animValue, const Animation* anim)
+static const TimingFunction* timingFunctionForAnimationValue(const AnimationValue* animValue, const PrimitiveAnimation* anim)
 {
     if (animValue->timingFunction())
         return animValue->timingFunction();
     if (anim->timingFunction())
         return anim->timingFunction().get();
 
     return CubicBezierTimingFunction::defaultTimingFunction();
 }
 
-GraphicsLayerAnimation::GraphicsLayerAnimation(const String& name, const KeyframeValueList& keyframes, const IntSize& boxSize, const Animation* animation, double startTime, bool listsMatch)
+GraphicsLayerAnimation::GraphicsLayerAnimation(const String& name, const KeyframeValueList& keyframes, const IntSize& boxSize, const PrimitiveAnimation* animation, double startTime, bool listsMatch)
     : m_keyframes(keyframes)
     , m_boxSize(boxSize)
-    , m_animation(Animation::create(animation))
+    , m_animation(PrimitiveAnimation::create(animation))
     , m_name(name)
     , m_listsMatch(listsMatch)
     , m_startTime(startTime)
     , m_pauseTime(0)
     , m_totalRunningTime(0)
     , m_lastRefreshedTime(m_startTime)
     , m_state(PlayingState)
 {
 }
 
@@ skipping 42 matching lines @@
 }
 
 void GraphicsLayerAnimation::apply(Client* client)
 {
     if (!isActive())
         return;
 
     double totalRunningTime = computeTotalRunningTime();
     double normalizedValue = normalizedAnimationValue(totalRunningTime, m_animation->duration(), m_animation->direction(), m_animation->iterationCount());
 
-    if (m_animation->iterationCount() != Animation::IterationCountInfinite && totalRunningTime >= m_animation->duration() * m_animation->iterationCount()) {
+    if (m_animation->iterationCount() != PrimitiveAnimation::IterationCountInfinite && totalRunningTime >= m_animation->duration() * m_animation->iterationCount()) {
         setState(StoppedState);
         if (m_animation->fillsForwards())
             normalizedValue = normalizedAnimationValueForFillsForwards(m_animation->iterationCount(), m_animation->direction());
     }
 
     if (!normalizedValue) {
         applyInternal(client, m_keyframes.at(0), m_keyframes.at(1), 0);
         return;
     }
 
@@ skipping 99 matching lines @@
 GraphicsLayerAnimations GraphicsLayerAnimations::getActiveAnimations() const
 {
     GraphicsLayerAnimations active;
     for (size_t i = 0; i < m_animations.size(); ++i) {
         if (m_animations[i].isActive())
             active.add(m_animations[i]);
     }
     return active;
 }
 }