Rename CSSAnimationData* -> StyleAnimationData*

Source/core/css/CSSComputedStyleDeclaration.cpp

 /*
  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2011 Sencha, Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ skipping 1039 matching lines @@
         return cssValuePool().createIdentifierValue(CSSValueAuto);
 
     if (position.isInteger())
         return cssValuePool().createValue(position.integerPosition(), CSSPrimitiveValue::CSS_NUMBER);
 
     RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     list->append(cssValuePool().createIdentifierValue(CSSValueSpan));
     list->append(cssValuePool().createValue(position.spanPosition(), CSSPrimitiveValue::CSS_NUMBER));
     return list;
 }
-static PassRefPtr<CSSValue> createTransitionPropertyValue(const CSSAnimationData* animation)
+static PassRefPtr<CSSValue> createTransitionPropertyValue(const StyleAnimationData* animation)
 {
     RefPtr<CSSValue> propertyValue;
-    if (animation->animationMode() == CSSAnimationData::AnimateNone)
+    if (animation->animationMode() == StyleAnimationData::AnimateNone)
         propertyValue = cssValuePool().createIdentifierValue(CSSValueNone);
-    else if (animation->animationMode() == CSSAnimationData::AnimateAll)
+    else if (animation->animationMode() == StyleAnimationData::AnimateAll)
         propertyValue = cssValuePool().createIdentifierValue(CSSValueAll);
     else
         propertyValue = cssValuePool().createValue(getPropertyNameString(animation->property()), CSSPrimitiveValue::CSS_STRING);
     return propertyValue.release();
 }
-static PassRefPtr<CSSValue> getTransitionPropertyValue(const CSSAnimationDataList* animList)
+static PassRefPtr<CSSValue> getTransitionPropertyValue(const StyleAnimationDataList* animList)
 {
     RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
     if (animList) {
         for (size_t i = 0; i < animList->size(); ++i)
             list->append(createTransitionPropertyValue(animList->animation(i)));
     } else
         list->append(cssValuePool().createIdentifierValue(CSSValueAll));
     return list.release();
 }
 
-static PassRefPtr<CSSValue> getDelayValue(const CSSAnimationDataList* animList)
+static PassRefPtr<CSSValue> getDelayValue(const StyleAnimationDataList* animList)
 {
     RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
     if (animList) {
         for (size_t i = 0; i < animList->size(); ++i)
             list->append(cssValuePool().createValue(animList->animation(i)->delay(), CSSPrimitiveValue::CSS_S));
     } else {
         // Note that initialAnimationDelay() is used for both transitions and animations
-        list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationDelay(), CSSPrimitiveValue::CSS_S));
+        list->append(cssValuePool().createValue(StyleAnimationData::initialAnimationDelay(), CSSPrimitiveValue::CSS_S));
     }
     return list.release();
 }
 
-static PassRefPtr<CSSValue> getDurationValue(const CSSAnimationDataList* animList)
+static PassRefPtr<CSSValue> getDurationValue(const StyleAnimationDataList* animList)
 {
     RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
     if (animList) {
         for (size_t i = 0; i < animList->size(); ++i)
             list->append(cssValuePool().createValue(animList->animation(i)->duration(), CSSPrimitiveValue::CSS_S));
     } else {
         // Note that initialAnimationDuration() is used for both transitions and animations
-        list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationDuration(), CSSPrimitiveValue::CSS_S));
+        list->append(cssValuePool().createValue(StyleAnimationData::initialAnimationDuration(), CSSPrimitiveValue::CSS_S));
     }
     return list.release();
 }
 
 static PassRefPtr<CSSValue> createTimingFunctionValue(const TimingFunction* timingFunction)
 {
     if (timingFunction->isCubicBezierTimingFunction()) {
         const CubicBezierTimingFunction* bezierTimingFunction = static_cast<const CubicBezierTimingFunction*>(timingFunction);
         if (bezierTimingFunction->timingFunctionPreset() != CubicBezierTimingFunction::Custom) {
             CSSValueID valueId = CSSValueInvalid;
@@ skipping 20 matching lines @@
     }
 
     if (timingFunction->isStepsTimingFunction()) {
         const StepsTimingFunction* stepsTimingFunction = static_cast<const StepsTimingFunction*>(timingFunction);
         return CSSStepsTimingFunctionValue::create(stepsTimingFunction->numberOfSteps(), stepsTimingFunction->stepAtStart());
     }
 
     return CSSLinearTimingFunctionValue::create();
 }
 
-static PassRefPtr<CSSValue> getTimingFunctionValue(const CSSAnimationDataList* animList)
+static PassRefPtr<CSSValue> getTimingFunctionValue(const StyleAnimationDataList* animList)
 {
     RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
     if (animList) {
         for (size_t i = 0; i < animList->size(); ++i)
             list->append(createTimingFunctionValue(animList->animation(i)->timingFunction().get()));
     } else
         // Note that initialAnimationTimingFunction() is used for both transitions and animations
-        list->append(createTimingFunctionValue(CSSAnimationData::initialAnimationTimingFunction().get()));
+        list->append(createTimingFunctionValue(StyleAnimationData::initialAnimationTimingFunction().get()));
     return list.release();
 }
 
 static PassRefPtr<CSSValue> createLineBoxContainValue(unsigned lineBoxContain)
 {
     if (!lineBoxContain)
         return cssValuePool().createIdentifierValue(CSSValueNone);
     return CSSLineBoxContainValue::create(lineBoxContain);
 }
 
@@ skipping 1115 matching lines @@
         case CSSPropertyBoxSizing:
             if (style->boxSizing() == CONTENT_BOX)
                 return cssValuePool().createIdentifierValue(CSSValueContentBox);
             return cssValuePool().createIdentifierValue(CSSValueBorderBox);
         case CSSPropertyWebkitAppRegion:
             return cssValuePool().createIdentifierValue(style->getDraggableRegionMode() == DraggableRegionDrag ? CSSValueDrag : CSSValueNoDrag);
         case CSSPropertyWebkitAnimationDelay:
             return getDelayValue(style->animations());
         case CSSPropertyWebkitAnimationDirection: {
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
-            const CSSAnimationDataList* t = style->animations();
+            const StyleAnimationDataList* t = style->animations();
             if (t) {
                 for (size_t i = 0; i < t->size(); ++i) {
                     if (t->animation(i)->direction())
                         list->append(cssValuePool().createIdentifierValue(CSSValueAlternate));
                     else
                         list->append(cssValuePool().createIdentifierValue(CSSValueNormal));
                 }
             } else
                 list->append(cssValuePool().createIdentifierValue(CSSValueNormal));
             return list.release();
         }
         case CSSPropertyWebkitAnimationDuration:
             return getDurationValue(style->animations());
         case CSSPropertyWebkitAnimationFillMode: {
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
-            const CSSAnimationDataList* t = style->animations();
+            const StyleAnimationDataList* t = style->animations();
             if (t) {
                 for (size_t i = 0; i < t->size(); ++i) {
                     switch (t->animation(i)->fillMode()) {
                     case AnimationFillModeNone:
                         list->append(cssValuePool().createIdentifierValue(CSSValueNone));
                         break;
                     case AnimationFillModeForwards:
                         list->append(cssValuePool().createIdentifierValue(CSSValueForwards));
                         break;
                     case AnimationFillModeBackwards:
                         list->append(cssValuePool().createIdentifierValue(CSSValueBackwards));
                         break;
                     case AnimationFillModeBoth:
                         list->append(cssValuePool().createIdentifierValue(CSSValueBoth));
                         break;
                     }
                 }
             } else
                 list->append(cssValuePool().createIdentifierValue(CSSValueNone));
             return list.release();
         }
         case CSSPropertyWebkitAnimationIterationCount: {
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
-            const CSSAnimationDataList* t = style->animations();
+            const StyleAnimationDataList* t = style->animations();
             if (t) {
                 for (size_t i = 0; i < t->size(); ++i) {
                     double iterationCount = t->animation(i)->iterationCount();
-                    if (iterationCount == CSSAnimationData::IterationCountInfinite)
+                    if (iterationCount == StyleAnimationData::IterationCountInfinite)
                         list->append(cssValuePool().createIdentifierValue(CSSValueInfinite));
                     else
                         list->append(cssValuePool().createValue(iterationCount, CSSPrimitiveValue::CSS_NUMBER));
                 }
             } else
-                list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationIterationCount(), CSSPrimitiveValue::CSS_NUMBER));
+                list->append(cssValuePool().createValue(StyleAnimationData::initialAnimationIterationCount(), CSSPrimitiveValue::CSS_NUMBER));
             return list.release();
         }
         case CSSPropertyWebkitAnimationName: {
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
-            const CSSAnimationDataList* t = style->animations();
+            const StyleAnimationDataList* t = style->animations();
             if (t) {
                 for (size_t i = 0; i < t->size(); ++i)
                     list->append(cssValuePool().createValue(t->animation(i)->name(), CSSPrimitiveValue::CSS_STRING));
             } else
                 list->append(cssValuePool().createIdentifierValue(CSSValueNone));
             return list.release();
         }
         case CSSPropertyWebkitAnimationPlayState: {
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
-            const CSSAnimationDataList* t = style->animations();
+            const StyleAnimationDataList* t = style->animations();
             if (t) {
                 for (size_t i = 0; i < t->size(); ++i) {
                     int prop = t->animation(i)->playState();
                     if (prop == AnimPlayStatePlaying)
                         list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
                     else
                         list->append(cssValuePool().createIdentifierValue(CSSValuePaused));
                 }
             } else
                 list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
@@ skipping 129 matching lines @@
         case CSSPropertyWebkitTransitionDuration:
             return getDurationValue(style->transitions());
         case CSSPropertyTransitionProperty:
         case CSSPropertyWebkitTransitionProperty:
             return getTransitionPropertyValue(style->transitions());
         case CSSPropertyTransitionTimingFunction:
         case CSSPropertyWebkitTransitionTimingFunction:
             return getTimingFunctionValue(style->transitions());
         case CSSPropertyTransition:
         case CSSPropertyWebkitTransition: {
-            const CSSAnimationDataList* animList = style->transitions();
+            const StyleAnimationDataList* animList = style->transitions();
             if (animList) {
                 RefPtr<CSSValueList> transitionsList = CSSValueList::createCommaSeparated();
                 for (size_t i = 0; i < animList->size(); ++i) {
                     RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
-                    const CSSAnimationData* animation = animList->animation(i);
+                    const StyleAnimationData* animation = animList->animation(i);
                     list->append(createTransitionPropertyValue(animation));
                     list->append(cssValuePool().createValue(animation->duration(), CSSPrimitiveValue::CSS_S));
                     list->append(createTimingFunctionValue(animation->timingFunction().get()));
                     list->append(cssValuePool().createValue(animation->delay(), CSSPrimitiveValue::CSS_S));
                     transitionsList->append(list);
                 }
                 return transitionsList.release();
             }
 
             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
             // transition-property default value.
             list->append(cssValuePool().createIdentifierValue(CSSValueAll));
-            list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationDuration(), CSSPrimitiveValue::CSS_S));
-            list->append(createTimingFunctionValue(CSSAnimationData::initialAnimationTimingFunction().get()));
-            list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationDelay(), CSSPrimitiveValue::CSS_S));
+            list->append(cssValuePool().createValue(StyleAnimationData::initialAnimationDuration(), CSSPrimitiveValue::CSS_S));
+            list->append(createTimingFunctionValue(StyleAnimationData::initialAnimationTimingFunction().get()));
+            list->append(cssValuePool().createValue(StyleAnimationData::initialAnimationDelay(), CSSPrimitiveValue::CSS_S));
             return list.release();
         }
         case CSSPropertyPointerEvents:
             return cssValuePool().createValue(style->pointerEvents());
         case CSSPropertyWebkitColorCorrection:
             return cssValuePool().createValue(style->colorSpace());
         case CSSPropertyWebkitLineGrid:
             if (style->lineGrid().isNull())
                 return cssValuePool().createIdentifierValue(CSSValueNone);
             return cssValuePool().createValue(style->lineGrid(), CSSPrimitiveValue::CSS_STRING);
@@ skipping 459 matching lines @@
     static const CSSPropertyID propertiesAfterSlashSeperator[3] = { CSSPropertyBackgroundSize, CSSPropertyBackgroundOrigin, 
                                                                     CSSPropertyBackgroundClip };
 
     RefPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
     list->append(getCSSPropertyValuesForShorthandProperties(StylePropertyShorthand(propertiesBeforeSlashSeperator, WTF_ARRAY_LENGTH(propertiesBeforeSlashSeperator))));
     list->append(getCSSPropertyValuesForShorthandProperties(StylePropertyShorthand(propertiesAfterSlashSeperator, WTF_ARRAY_LENGTH(propertiesAfterSlashSeperator))));
     return list.release();
 }
 
 } // namespace WebCore