Enable/Unprefix Animations & Transitions, add basic tests

sky/engine/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 175 matching lines @@
     CSSPropertyVerticalAlign,
     CSSPropertyWhiteSpace,
     CSSPropertyWidows,
     CSSPropertyWidth,
     CSSPropertyWillChange,
     CSSPropertyWordBreak,
     CSSPropertyWordSpacing,
     CSSPropertyWordWrap,
     CSSPropertyZIndex,
 
-    CSSPropertyWebkitAnimationDelay,
-    CSSPropertyWebkitAnimationDirection,
-    CSSPropertyWebkitAnimationDuration,
-    CSSPropertyWebkitAnimationFillMode,
-    CSSPropertyWebkitAnimationIterationCount,
-    CSSPropertyWebkitAnimationName,
-    CSSPropertyWebkitAnimationPlayState,
-    CSSPropertyWebkitAnimationTimingFunction,
     CSSPropertyBackfaceVisibility,
     CSSPropertyWebkitBackfaceVisibility,
     CSSPropertyWebkitBackgroundClip,
     CSSPropertyWebkitBackgroundComposite,
     CSSPropertyWebkitBackgroundOrigin,
     CSSPropertyWebkitBackgroundSize,
     CSSPropertyWebkitBorderHorizontalSpacing,
     CSSPropertyWebkitBorderImage,
     CSSPropertyWebkitBorderVerticalSpacing,
     CSSPropertyWebkitBoxDecorationBreak,
@@ skipping 42 matching lines @@
     CSSPropertyWebkitTextFillColor,
     CSSPropertyWebkitTextOrientation,
     CSSPropertyWebkitTextStrokeColor,
     CSSPropertyWebkitTextStrokeWidth,
     CSSPropertyTransform,
     CSSPropertyWebkitTransform,
     CSSPropertyTransformOrigin,
     CSSPropertyWebkitTransformOrigin,
     CSSPropertyTransformStyle,
     CSSPropertyWebkitTransformStyle,
-    CSSPropertyWebkitTransitionDelay,
-    CSSPropertyWebkitTransitionDuration,
-    CSSPropertyWebkitTransitionProperty,
-    CSSPropertyWebkitTransitionTimingFunction,
     CSSPropertyWebkitUserDrag,
     CSSPropertyWebkitUserModify,
     CSSPropertyWebkitUserSelect,
     CSSPropertyMaskSourceType,
 };
 
 static const Vector<CSSPropertyID>& computableProperties()
 {
     DEFINE_STATIC_LOCAL(Vector<CSSPropertyID>, properties, ());
     if (properties.isEmpty())
@@ skipping 1585 matching lines @@
         }
         case CSSPropertyZIndex:
             if (style->hasAutoZIndex())
                 return cssValuePool().createIdentifierValue(CSSValueAuto);
             return cssValuePool().createValue(style->zIndex(), CSSPrimitiveValue::CSS_NUMBER);
         case CSSPropertyBoxSizing:
             if (style->boxSizing() == CONTENT_BOX)
                 return cssValuePool().createIdentifierValue(CSSValueContentBox);
             return cssValuePool().createIdentifierValue(CSSValueBorderBox);
         case CSSPropertyAnimationDelay:
-            ASSERT(RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled());
-        case CSSPropertyWebkitAnimationDelay:
             return valueForAnimationDelay(style->animations());
-        case CSSPropertyAnimationDirection:
-            ASSERT(RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled());
-        case CSSPropertyWebkitAnimationDirection: {
+        case CSSPropertyAnimationDirection: {
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
             const CSSAnimationData* animationData = style->animations();
             if (animationData) {
                 for (size_t i = 0; i < animationData->directionList().size(); ++i)
                     list->append(valueForAnimationDirection(animationData->directionList()[i]));
             } else {
                 list->append(cssValuePool().createIdentifierValue(CSSValueNormal));
             }
             return list.release();
         }
         case CSSPropertyAnimationDuration:
-            ASSERT(RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled());
-        case CSSPropertyWebkitAnimationDuration:
             return valueForAnimationDuration(style->animations());
-        case CSSPropertyAnimationFillMode:
-            ASSERT(RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled());
-        case CSSPropertyWebkitAnimationFillMode: {
+        case CSSPropertyAnimationFillMode: {
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
             const CSSAnimationData* animationData = style->animations();
             if (animationData) {
                 for (size_t i = 0; i < animationData->fillModeList().size(); ++i)
                     list->append(valueForAnimationFillMode(animationData->fillModeList()[i]));
             } else {
                 list->append(cssValuePool().createIdentifierValue(CSSValueNone));
             }
             return list.release();
         }
-        case CSSPropertyAnimationIterationCount:
-            ASSERT(RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled());
-        case CSSPropertyWebkitAnimationIterationCount: {
+        case CSSPropertyAnimationIterationCount: {
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
             const CSSAnimationData* animationData = style->animations();
             if (animationData) {
                 for (size_t i = 0; i < animationData->iterationCountList().size(); ++i)
                     list->append(valueForAnimationIterationCount(animationData->iterationCountList()[i]));
             } else {
                 list->append(cssValuePool().createValue(CSSAnimationData::initialIterationCount(), CSSPrimitiveValue::CSS_NUMBER));
             }
             return list.release();
         }
-        case CSSPropertyAnimationName:
-            ASSERT(RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled());
-        case CSSPropertyWebkitAnimationName: {
+        case CSSPropertyAnimationName: {
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
             const CSSAnimationData* animationData = style->animations();
             if (animationData) {
                 for (size_t i = 0; i < animationData->nameList().size(); ++i)
                     list->append(cssValuePool().createValue(animationData->nameList()[i], CSSPrimitiveValue::CSS_STRING));
             } else {
                 list->append(cssValuePool().createIdentifierValue(CSSValueNone));
             }
             return list.release();
         }
-        case CSSPropertyAnimationPlayState:
-            ASSERT(RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled());
-        case CSSPropertyWebkitAnimationPlayState: {
+        case CSSPropertyAnimationPlayState: {
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
             const CSSAnimationData* animationData = style->animations();
             if (animationData) {
                 for (size_t i = 0; i < animationData->playStateList().size(); ++i)
                     list->append(valueForAnimationPlayState(animationData->playStateList()[i]));
             } else {
                 list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
             }
             return list.release();
         }
         case CSSPropertyAnimationTimingFunction:
-            ASSERT(RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled());
-        case CSSPropertyWebkitAnimationTimingFunction:
             return valueForAnimationTimingFunction(style->animations());
-        case CSSPropertyAnimation:
-        case CSSPropertyWebkitAnimation: {
+        case CSSPropertyAnimation: {
             const CSSAnimationData* animationData = style->animations();
             if (animationData) {
                 RefPtr<CSSValueList> animationsList = CSSValueList::createCommaSeparated();
                 for (size_t i = 0; i < animationData->nameList().size(); ++i) {
                     RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
                     list->append(cssValuePool().createValue(animationData->nameList()[i], CSSPrimitiveValue::CSS_STRING));
                     list->append(cssValuePool().createValue(CSSTimingData::getRepeated(animationData->durationList(), i), CSSPrimitiveValue::CSS_S));
                     list->append(createTimingFunctionValue(CSSTimingData::getRepeated(animationData->timingFunctionList(), i).get()));
                     list->append(cssValuePool().createValue(CSSTimingData::getRepeated(animationData->delayList(), i), CSSPrimitiveValue::CSS_S));
                     list->append(valueForAnimationIterationCount(CSSTimingData::getRepeated(animationData->iterationCountList(), i)));
@@ skipping 123 matching lines @@
                 list->append(pixelValueForLength(style->transformOriginY(), *style));
                 if (style->transformOriginZ() != 0)
                     list->append(pixelValue(style->transformOriginZ(), *style));
             }
             return list.release();
         }
         case CSSPropertyTransformStyle:
         case CSSPropertyWebkitTransformStyle:
             return cssValuePool().createIdentifierValue((style->transformStyle3D() == TransformStyle3DPreserve3D) ? CSSValuePreserve3d : CSSValueFlat);
         case CSSPropertyTransitionDelay:
-        case CSSPropertyWebkitTransitionDelay:
             return valueForAnimationDelay(style->transitions());
         case CSSPropertyTransitionDuration:
-        case CSSPropertyWebkitTransitionDuration:
             return valueForAnimationDuration(style->transitions());
         case CSSPropertyTransitionProperty:
-        case CSSPropertyWebkitTransitionProperty:
             return valueForTransitionProperty(style->transitions());
         case CSSPropertyTransitionTimingFunction:
-        case CSSPropertyWebkitTransitionTimingFunction:
             return valueForAnimationTimingFunction(style->transitions());
-        case CSSPropertyTransition:
-        case CSSPropertyWebkitTransition: {
+        case CSSPropertyTransition: {
             const CSSTransitionData* transitionData = style->transitions();
             if (transitionData) {
                 RefPtr<CSSValueList> transitionsList = CSSValueList::createCommaSeparated();
                 for (size_t i = 0; i < transitionData->propertyList().size(); ++i) {
                     RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
                     list->append(createTransitionPropertyValue(transitionData->propertyList()[i]));
                     list->append(cssValuePool().createValue(CSSTimingData::getRepeated(transitionData->durationList(), i), CSSPrimitiveValue::CSS_S));
                     list->append(createTimingFunctionValue(CSSTimingData::getRepeated(transitionData->timingFunctionList(), i).get()));
                     list->append(cssValuePool().createValue(CSSTimingData::getRepeated(transitionData->delayList(), i), CSSPrimitiveValue::CSS_S));
                     transitionsList->append(list);
@@ skipping 310 matching lines @@
     static const CSSPropertyID propertiesAfterSlashSeperator[3] = { CSSPropertyBackgroundSize, CSSPropertyBackgroundOrigin,
                                                                     CSSPropertyBackgroundClip };
 
     RefPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
     list->append(valuesForShorthandProperty(StylePropertyShorthand(CSSPropertyBackground, propertiesBeforeSlashSeperator, WTF_ARRAY_LENGTH(propertiesBeforeSlashSeperator))));
     list->append(valuesForShorthandProperty(StylePropertyShorthand(CSSPropertyBackground, propertiesAfterSlashSeperator, WTF_ARRAY_LENGTH(propertiesAfterSlashSeperator))));
     return list.release();
 }
 
 } // namespace blink