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 18 matching lines @@
 #include "core/css/CSSToStyleMap.h"
 
 #include "CSSValueKeywords.h"
 #include "core/css/CSSBorderImageSliceValue.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSTimingFunctionValue.h"
 #include "core/css/Pair.h"
 #include "core/css/Rect.h"
 #include "core/css/StyleResolver.h"
-#include "core/platform/animation/Animation.h"
+#include "core/platform/animation/CSSAnimationData.h"
 #include "core/rendering/style/FillLayer.h"
 
 namespace WebCore {
 
 RenderStyle* CSSToStyleMap::style() const
 {
     return m_resolver->style();
 }
     
 RenderStyle* CSSToStyleMap::rootElementStyle() const
@@ skipping 242 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(CSSAnimationData* animation, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        animation->setDelay(Animation::initialAnimationDelay());
+        animation->setDelay(CSSAnimationData::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(CSSAnimationData* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        layer->setDirection(Animation::initialAnimationDirection());
+        layer->setDirection(CSSAnimationData::initialAnimationDirection());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
     switch (primitiveValue->getIdent()) {
     case CSSValueNormal:
-        layer->setDirection(Animation::AnimationDirectionNormal);
+        layer->setDirection(CSSAnimationData::AnimationDirectionNormal);
         break;
     case CSSValueAlternate:
-        layer->setDirection(Animation::AnimationDirectionAlternate);
+        layer->setDirection(CSSAnimationData::AnimationDirectionAlternate);
         break;
     case CSSValueReverse:
-        layer->setDirection(Animation::AnimationDirectionReverse);
+        layer->setDirection(CSSAnimationData::AnimationDirectionReverse);
         break;
     case CSSValueAlternateReverse:
-        layer->setDirection(Animation::AnimationDirectionAlternateReverse);
+        layer->setDirection(CSSAnimationData::AnimationDirectionAlternateReverse);
         break;
     }
 }
 
-void CSSToStyleMap::mapAnimationDuration(Animation* animation, CSSValue* value)
+void CSSToStyleMap::mapAnimationDuration(CSSAnimationData* animation, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        animation->setDuration(Animation::initialAnimationDuration());
+        animation->setDuration(CSSAnimationData::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(CSSAnimationData* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        layer->setFillMode(Animation::initialAnimationFillMode());
+        layer->setFillMode(CSSAnimationData::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(CSSAnimationData* animation, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        animation->setIterationCount(Animation::initialAnimationIterationCount());
+        animation->setIterationCount(CSSAnimationData::initialAnimationIterationCount());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
     if (primitiveValue->getIdent() == CSSValueInfinite)
-        animation->setIterationCount(Animation::IterationCountInfinite);
+        animation->setIterationCount(CSSAnimationData::IterationCountInfinite);
     else
         animation->setIterationCount(primitiveValue->getFloatValue());
 }
 
-void CSSToStyleMap::mapAnimationName(Animation* layer, CSSValue* value)
+void CSSToStyleMap::mapAnimationName(CSSAnimationData* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        layer->setName(Animation::initialAnimationName());
+        layer->setName(CSSAnimationData::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(CSSAnimationData* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        layer->setPlayState(Animation::initialAnimationPlayState());
+        layer->setPlayState(CSSAnimationData::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(CSSAnimationData* animation, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        animation->setAnimationMode(Animation::AnimateAll);
+        animation->setAnimationMode(CSSAnimationData::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(CSSAnimationData::AnimateAll);
         animation->setProperty(CSSPropertyInvalid);
     } else if (primitiveValue->getIdent() == CSSValueNone) {
-        animation->setAnimationMode(Animation::AnimateNone);
+        animation->setAnimationMode(CSSAnimationData::AnimateNone);
         animation->setProperty(CSSPropertyInvalid);
     } else {
-        animation->setAnimationMode(Animation::AnimateSingleProperty);
+        animation->setAnimationMode(CSSAnimationData::AnimateSingleProperty);
         animation->setProperty(static_cast<CSSPropertyID>(primitiveValue->getIdent()));
     }
 }
 
-void CSSToStyleMap::mapAnimationTimingFunction(Animation* animation, CSSValue* value)
+void CSSToStyleMap::mapAnimationTimingFunction(CSSAnimationData* animation, CSSValue* value)
 {
     if (value->isInitialValue()) {
-        animation->setTimingFunction(Animation::initialAnimationTimingFunction());
+        animation->setTimingFunction(CSSAnimationData::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);
 }
 
 };