Implement computed style for animation shorthand and align parsing with the spec.

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 1171 matching lines @@
     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()));
     return list.release();
 }
 
+static PassRefPtr<CSSValue> valueForAnimationFillMode(unsigned fillMode)
+{
+    switch (fillMode) {
+    case AnimationFillModeNone:
+        return cssValuePool().createIdentifierValue(CSSValueNone);
+    case AnimationFillModeForwards:
+        return cssValuePool().createIdentifierValue(CSSValueForwards);
+    case AnimationFillModeBackwards:
+        return cssValuePool().createIdentifierValue(CSSValueBackwards);
+    case AnimationFillModeBoth:
+        return cssValuePool().createIdentifierValue(CSSValueBoth);
+    default:
+        ASSERT_NOT_REACHED();
+        return 0;
+    }
+}
+
+static PassRefPtr<CSSValue> valueForAnimationDirection(CSSAnimationData::AnimationDirection direction)
+{
+    switch (direction) {
+    case CSSAnimationData::AnimationDirectionNormal:
+        return cssValuePool().createIdentifierValue(CSSValueNormal);
+    case CSSAnimationData::AnimationDirectionAlternate:
+        return cssValuePool().createIdentifierValue(CSSValueAlternate);
+    case CSSAnimationData::AnimationDirectionReverse:
+        return cssValuePool().createIdentifierValue(CSSValueReverse);
+    case CSSAnimationData::AnimationDirectionAlternateReverse:
+        return cssValuePool().createIdentifierValue(CSSValueAlternateReverse);
+    default:
+        ASSERT_NOT_REACHED();
+        return 0;
+    }
+}
+
 static PassRefPtr<CSSValue> createLineBoxContainValue(unsigned lineBoxContain)
 {
     if (!lineBoxContain)
         return cssValuePool().createIdentifierValue(CSSValueNone);
     return CSSLineBoxContainValue::create(lineBoxContain);
 }
 
 CSSComputedStyleDeclaration::CSSComputedStyleDeclaration(PassRefPtr<Node> n, bool allowVisitedStyle, const String& pseudoElementName)
     : m_node(n)
     , m_allowVisitedStyle(allowVisitedStyle)
@@ skipping 1141 matching lines @@
                 break;
         case CSSPropertyWebkitAnimationDelay:
             return getDelayValue(style->animations());
         case CSSPropertyAnimationDirection:
             if (!RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled())
                 break;
         case CSSPropertyWebkitAnimationDirection: {
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
             const CSSAnimationDataList* t = style->animations();
             if (t) {
-                for (size_t i = 0; i < t->size(); ++i) {
-                    switch (t->animation(i)->direction()) {
-                    case CSSAnimationData::AnimationDirectionNormal:
-                        list->append(cssValuePool().createIdentifierValue(CSSValueNormal));
-                        break;
-                    case CSSAnimationData::AnimationDirectionAlternate:
-                        list->append(cssValuePool().createIdentifierValue(CSSValueAlternate));
-                        break;
-                    case CSSAnimationData::AnimationDirectionReverse:
-                        list->append(cssValuePool().createIdentifierValue(CSSValueReverse));
-                        break;
-                    case CSSAnimationData::AnimationDirectionAlternateReverse:
-                        list->append(cssValuePool().createIdentifierValue(CSSValueAlternateReverse));
-                        break;
-                    default:
-                        ASSERT_NOT_REACHED();
-                    }
-                }
+                for (size_t i = 0; i < t->size(); ++i)
+                    list->append(valueForAnimationDirection(t->animation(i)->direction()));
             } else
                 list->append(cssValuePool().createIdentifierValue(CSSValueNormal));
             return list.release();
         }
         case CSSPropertyAnimationDuration:
             if (!RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled())
                 break;
         case CSSPropertyWebkitAnimationDuration:
             return getDurationValue(style->animations());
         case CSSPropertyAnimationFillMode:
             if (!RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled())
                 break;
         case CSSPropertyWebkitAnimationFillMode: {
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
             const CSSAnimationDataList* 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;
-                    }
-                }
+                for (size_t i = 0; i < t->size(); ++i)
+                    list->append(valueForAnimationFillMode(t->animation(i)->fillMode()));
             } else
                 list->append(cssValuePool().createIdentifierValue(CSSValueNone));
             return list.release();
         }
         case CSSPropertyAnimationIterationCount:
             if (!RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled())
                 break;
         case CSSPropertyWebkitAnimationIterationCount: {
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
             const CSSAnimationDataList* t = style->animations();
@@ skipping 38 matching lines @@
                 }
             } else
                 list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
             return list.release();
         }
         case CSSPropertyAnimationTimingFunction:
             if (!RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled())
                 break;
         case CSSPropertyWebkitAnimationTimingFunction:
             return getTimingFunctionValue(style->animations());
+        case CSSPropertyAnimation:
+        case CSSPropertyWebkitAnimation: {
+            const CSSAnimationDataList* animations = style->animations();
+            if (animations) {
+                RefPtr<CSSValueList> animationsList = CSSValueList::createCommaSeparated();
+                for (size_t i = 0; i < animations->size(); ++i) {
+                    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+                    const CSSAnimationData* animation = animations->animation(i);
+                    list->append(cssValuePool().createValue(animation->name(), CSSPrimitiveValue::CSS_STRING));
+                    list->append(cssValuePool().createValue(animation->duration(), CSSPrimitiveValue::CSS_S));
+                    list->append(createTimingFunctionValue(animation->timingFunction().get()));
+                    list->append(cssValuePool().createValue(animation->delay(), CSSPrimitiveValue::CSS_S));
+                    if (animation->iterationCount() == CSSAnimationData::IterationCountInfinite)
+                        list->append(cssValuePool().createIdentifierValue(CSSValueInfinite));
+                    else
+                        list->append(cssValuePool().createValue(animation->iterationCount(), CSSPrimitiveValue::CSS_NUMBER));
+                    list->append(valueForAnimationDirection(animation->direction()));
+                    list->append(valueForAnimationFillMode(animation->fillMode()));
+                    if (animation->playState() == AnimPlayStatePaused)
+                        list->append(cssValuePool().createIdentifierValue(CSSValuePaused));
+                    else
+                        list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
+                    animationsList->append(list);
+                }
+                return animationsList.release();
+            }
+
+            RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+            // animation-name default value.
+            list->append(cssValuePool().createIdentifierValue(CSSValueNone));
+            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(CSSAnimationData::initialAnimationIterationCount(), CSSPrimitiveValue::CSS_NUMBER));
+            list->append(valueForAnimationDirection(CSSAnimationData::initialAnimationDirection()));
+            list->append(valueForAnimationFillMode(CSSAnimationData::initialAnimationFillMode()));
+            // Initial animation-play-state.
+            list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
+            return list.release();
+        }
         case CSSPropertyWebkitAppearance:
             return cssValuePool().createValue(style->appearance());
         case CSSPropertyWebkitAspectRatio:
             if (!style->hasAspectRatio())
                 return cssValuePool().createIdentifierValue(CSSValueNone);
             return CSSAspectRatioValue::create(style->aspectRatioNumerator(), style->aspectRatioDenominator());
         case CSSPropertyWebkitBackfaceVisibility:
             return cssValuePool().createIdentifierValue((style->backfaceVisibility() == BackfaceVisibilityHidden) ? CSSValueHidden : CSSValueVisible);
         case CSSPropertyWebkitBorderImage:
             return valueForNinePieceImage(style->borderImage());
@@ skipping 332 matching lines @@
         case CSSPropertyUnicodeRange:
             break;
 
         /* Other unimplemented properties */
         case CSSPropertyPage: // for @page
         case CSSPropertyQuotes: // FIXME: needs implementation
         case CSSPropertySize: // for @page
             break;
 
         /* Unimplemented -webkit- properties */
-        case CSSPropertyAnimation:
-        case CSSPropertyWebkitAnimation:
         case CSSPropertyWebkitBorderRadius:
         case CSSPropertyWebkitMarginCollapse:
         case CSSPropertyWebkitMarquee:
         case CSSPropertyWebkitMarqueeSpeed:
         case CSSPropertyWebkitMask:
         case CSSPropertyWebkitMaskRepeatX:
         case CSSPropertyWebkitMaskRepeatY:
         case CSSPropertyWebkitPerspectiveOriginX:
         case CSSPropertyWebkitPerspectiveOriginY:
         case CSSPropertyWebkitTextStroke:
@@ skipping 291 matching lines @@
     static const CSSPropertyID propertiesAfterSlashSeperator[3] = { CSSPropertyBackgroundSize, CSSPropertyBackgroundOrigin,
                                                                     CSSPropertyBackgroundClip };
 
     RefPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
     list->append(getCSSPropertyValuesForShorthandProperties(StylePropertyShorthand(CSSPropertyBackground, propertiesBeforeSlashSeperator, WTF_ARRAY_LENGTH(propertiesBeforeSlashSeperator))));
     list->append(getCSSPropertyValuesForShorthandProperties(StylePropertyShorthand(CSSPropertyBackground, propertiesAfterSlashSeperator, WTF_ARRAY_LENGTH(propertiesAfterSlashSeperator))));
     return list.release();
 }
 
 } // namespace WebCore