Rename Animation -> PrimitiveAnimation

Source/core/css/CSSToStyleMap.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 10 matching lines @@
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 #include "CSSToStyleMap.h"
 
-#include "Animation.h"
+#include "PrimitiveAnimation.h"
 #include "CSSBorderImageSliceValue.h"
 #include "CSSPrimitiveValue.h"
 #include "CSSPrimitiveValueMappings.h"
 #include "CSSTimingFunctionValue.h"
 #include "CSSValueKeywords.h"
 #include "FillLayer.h"
 #include "Pair.h"
 #include "Rect.h"
 #include "StyleResolver.h"
 
@@ skipping 250 matching lines @@
     else if (primitiveValue->isViewportPercentageLength())
         length = primitiveValue->viewportPercentageLength();
     else
         return;
 
     layer->setYPosition(length);
     if (pair)
         layer->setBackgroundYOrigin(*(pair->first()));
 }
 
-void CSSToStyleMap::mapAnimationDelay(Animation* animation, CSSValue* value)
+void CSSToStyleMap::mapAnimationDelay(PrimitiveAnimation* animation, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        animation->setDelay(Animation::initialAnimationDelay());
+        animation->setDelay(PrimitiveAnimation::initialAnimationDelay());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
     animation->setDelay(primitiveValue->computeTime<double, CSSPrimitiveValue::Seconds>());
 }
 
-void CSSToStyleMap::mapAnimationDirection(Animation* layer, CSSValue* value)
+void CSSToStyleMap::mapAnimationDirection(PrimitiveAnimation* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        layer->setDirection(Animation::initialAnimationDirection());
+        layer->setDirection(PrimitiveAnimation::initialAnimationDirection());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
     switch (primitiveValue->getIdent()) {
     case CSSValueNormal:
-        layer->setDirection(Animation::AnimationDirectionNormal);
+        layer->setDirection(PrimitiveAnimation::AnimationDirectionNormal);
         break;
     case CSSValueAlternate:
-        layer->setDirection(Animation::AnimationDirectionAlternate);
+        layer->setDirection(PrimitiveAnimation::AnimationDirectionAlternate);
         break;
     case CSSValueReverse:
-        layer->setDirection(Animation::AnimationDirectionReverse);
+        layer->setDirection(PrimitiveAnimation::AnimationDirectionReverse);
         break;
     case CSSValueAlternateReverse:
-        layer->setDirection(Animation::AnimationDirectionAlternateReverse);
+        layer->setDirection(PrimitiveAnimation::AnimationDirectionAlternateReverse);
         break;
     }
 }
 
-void CSSToStyleMap::mapAnimationDuration(Animation* animation, CSSValue* value)
+void CSSToStyleMap::mapAnimationDuration(PrimitiveAnimation* animation, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        animation->setDuration(Animation::initialAnimationDuration());
+        animation->setDuration(PrimitiveAnimation::initialAnimationDuration());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
     animation->setDuration(primitiveValue->computeTime<double, CSSPrimitiveValue::Seconds>());
 }
 
-void CSSToStyleMap::mapAnimationFillMode(Animation* layer, CSSValue* value)
+void CSSToStyleMap::mapAnimationFillMode(PrimitiveAnimation* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        layer->setFillMode(Animation::initialAnimationFillMode());
+        layer->setFillMode(PrimitiveAnimation::initialAnimationFillMode());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
     switch (primitiveValue->getIdent()) {
     case CSSValueNone:
         layer->setFillMode(AnimationFillModeNone);
         break;
     case CSSValueForwards:
         layer->setFillMode(AnimationFillModeForwards);
         break;
     case CSSValueBackwards:
         layer->setFillMode(AnimationFillModeBackwards);
         break;
     case CSSValueBoth:
         layer->setFillMode(AnimationFillModeBoth);
         break;
     }
 }
 
-void CSSToStyleMap::mapAnimationIterationCount(Animation* animation, CSSValue* value)
+void CSSToStyleMap::mapAnimationIterationCount(PrimitiveAnimation* animation, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        animation->setIterationCount(Animation::initialAnimationIterationCount());
+        animation->setIterationCount(PrimitiveAnimation::initialAnimationIterationCount());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
     if (primitiveValue->getIdent() == CSSValueInfinite)
-        animation->setIterationCount(Animation::IterationCountInfinite);
+        animation->setIterationCount(PrimitiveAnimation::IterationCountInfinite);
     else
         animation->setIterationCount(primitiveValue->getFloatValue());
 }
 
-void CSSToStyleMap::mapAnimationName(Animation* layer, CSSValue* value)
+void CSSToStyleMap::mapAnimationName(PrimitiveAnimation* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        layer->setName(Animation::initialAnimationName());
+        layer->setName(PrimitiveAnimation::initialAnimationName());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
     if (primitiveValue->getIdent() == CSSValueNone)
         layer->setIsNoneAnimation(true);
     else
         layer->setName(primitiveValue->getStringValue());
 }
 
-void CSSToStyleMap::mapAnimationPlayState(Animation* layer, CSSValue* value)
+void CSSToStyleMap::mapAnimationPlayState(PrimitiveAnimation* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        layer->setPlayState(Animation::initialAnimationPlayState());
+        layer->setPlayState(PrimitiveAnimation::initialAnimationPlayState());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
     EAnimPlayState playState = (primitiveValue->getIdent() == CSSValuePaused) ? AnimPlayStatePaused : AnimPlayStatePlaying;
     layer->setPlayState(playState);
 }
 
-void CSSToStyleMap::mapAnimationProperty(Animation* animation, CSSValue* value)
+void CSSToStyleMap::mapAnimationProperty(PrimitiveAnimation* animation, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        animation->setAnimationMode(Animation::AnimateAll);
+        animation->setAnimationMode(PrimitiveAnimation::AnimateAll);
         animation->setProperty(CSSPropertyInvalid);
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
     if (primitiveValue->getIdent() == CSSValueAll) {
-        animation->setAnimationMode(Animation::AnimateAll);
+        animation->setAnimationMode(PrimitiveAnimation::AnimateAll);
         animation->setProperty(CSSPropertyInvalid);
     } else if (primitiveValue->getIdent() == CSSValueNone) {
-        animation->setAnimationMode(Animation::AnimateNone);
+        animation->setAnimationMode(PrimitiveAnimation::AnimateNone);
         animation->setProperty(CSSPropertyInvalid);
     } else {
-        animation->setAnimationMode(Animation::AnimateSingleProperty);
+        animation->setAnimationMode(PrimitiveAnimation::AnimateSingleProperty);
         animation->setProperty(static_cast<CSSPropertyID>(primitiveValue->getIdent()));
     }
 }
 
-void CSSToStyleMap::mapAnimationTimingFunction(Animation* animation, CSSValue* value)
+void CSSToStyleMap::mapAnimationTimingFunction(PrimitiveAnimation* animation, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        animation->setTimingFunction(Animation::initialAnimationTimingFunction());
+        animation->setTimingFunction(PrimitiveAnimation::initialAnimationTimingFunction());
         return;
     }
 
     if (value->isPrimitiveValue()) {
         CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
         switch (primitiveValue->getIdent()) {
         case CSSValueLinear:
             animation->setTimingFunction(LinearTimingFunction::create());
             break;
         case CSSValueEase:
@@ skipping 211 matching lines @@
         verticalRule = SpaceImageRule;
         break;
     default: // CSSValueRepeat
         verticalRule = RepeatImageRule;
         break;
     }
     image.setVerticalRule(verticalRule);
 }
 
 };