Add support to resolve unprefixed CSS animations properties.

Source/core/css/StylePropertyShorthandCustom.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 18 matching lines @@
     static const CSSPropertyID borderShorthandProperties[] = { CSSPropertyBorderWidth, CSSPropertyBorderStyle, CSSPropertyBorderColor };
     static const StylePropertyShorthand* propertiesForInitialization[] = {
         &borderWidthShorthand(),
         &borderStyleShorthand(),
         &borderColorShorthand(),
     };
     DEFINE_STATIC_LOCAL(StylePropertyShorthand, borderForParsingLonghands, (CSSPropertyBorder, borderShorthandProperties, propertiesForInitialization, WTF_ARRAY_LENGTH(borderShorthandProperties)));
     return borderForParsingLonghands;
 }
 
+const StylePropertyShorthand& animationShorthandForParsing()
+{
+    // When we parse the animation shorthand we need to look for animation-name
+    // last because otherwise it might match against the keywords for fill mode,
+    // timing functions and infinite iteration. This means that animation names
+    // that are the same as keywords (e.g. 'forwards') won't always match in the
+    // shorthand. In that case the authors should be using longhands (or
+    // reconsidering their approach). This is covered by the animations spec
+    // bug: https://www.w3.org/Bugs/Public/show_bug.cgi?id=14790
+    // And in the spec (editor's draft) at:
+    // http://dev.w3.org/csswg/css3-animations/#animation-shorthand-property
+    static const CSSPropertyID animationPropertiesForParsing[] = {
+        CSSPropertyAnimationDuration,
+        CSSPropertyAnimationTimingFunction,
+        CSSPropertyAnimationDelay,
+        CSSPropertyAnimationIterationCount,
+        CSSPropertyAnimationDirection,
+        CSSPropertyAnimationFillMode,
+        CSSPropertyAnimationName
+    };
+    DEFINE_STATIC_LOCAL(StylePropertyShorthand, webkitAnimationLonghandsForParsing, (CSSPropertyAnimation, animationPropertiesForParsing, WTF_ARRAY_LENGTH(animationPropertiesForParsing)));
+    return webkitAnimationLonghandsForParsing;
+}
+
 const StylePropertyShorthand& webkitAnimationShorthandForParsing()
 {
     // When we parse the animation shorthand we need to look for animation-name
     // last because otherwise it might match against the keywords for fill mode,
     // timing functions and infinite iteration. This means that animation names
     // that are the same as keywords (e.g. 'forwards') won't always match in the
     // shorthand. In that case the authors should be using longhands (or
     // reconsidering their approach). This is covered by the animations spec
     // bug: https://www.w3.org/Bugs/Public/show_bug.cgi?id=14790
     // And in the spec (editor's draft) at:
     // http://dev.w3.org/csswg/css3-animations/#animation-shorthand-property
     static const CSSPropertyID animationPropertiesForParsing[] = {
         CSSPropertyWebkitAnimationDuration,
         CSSPropertyWebkitAnimationTimingFunction,
         CSSPropertyWebkitAnimationDelay,
         CSSPropertyWebkitAnimationIterationCount,
         CSSPropertyWebkitAnimationDirection,
         CSSPropertyWebkitAnimationFillMode,
         CSSPropertyWebkitAnimationName
     };
     DEFINE_STATIC_LOCAL(StylePropertyShorthand, webkitAnimationLonghandsForParsing, (CSSPropertyWebkitAnimation, animationPropertiesForParsing, WTF_ARRAY_LENGTH(animationPropertiesForParsing)));
     return webkitAnimationLonghandsForParsing;
 }
 
+// Returns an empty list if the property is not a shorthand, otherwise the list of longhands for parsing.
+const StylePropertyShorthand& parsingShorthandForProperty(CSSPropertyID propertyID)

[eseidel, 2013/08/13 17:49:15]

I'm confused by this new wrapper around shorthandForProperty?  I see, we're just
trying to support these as parse-only?

[darktears, 2013/08/13 18:08:54]

No. When we parse the shorthand properties we start matching them following the
order of declaration as in the spec (e.g. border-top then border-right then
border-bottom then border-left) but in few cases this order is different (or you
want to enforce it) when parsing (note that the array generated in
StylePropertyShorthand template is used also to construct the CSSOM and
cssText() values). Concrete example in the case of the animation is that you
want to try parse the animation name last as you still want to match the
keywords first (animation-name can be anything per the spec). I hope I made it
clear. This function only use the set of longhands in a different order for
parsing purpose.

+{
+    switch (propertyID) {
+    case CSSPropertyAnimation:
+        return animationShorthandForParsing();
+    case CSSPropertyBorder:
+        return borderShorthandForParsing();
+    case CSSPropertyWebkitAnimation:
+        return webkitAnimationShorthandForParsing();
+    default:
+        return shorthandForProperty(propertyID);
+    }
+}
+
 bool isExpandedShorthand(CSSPropertyID id)
 {
     // The system fonts bypass the normal style resolution by using RenderTheme,
     // thus we need to special case it here. FIXME: This is a violation of CSS 3 Fonts
     // as we should still be able to change the longhands.
     // DON'T ADD ANY SHORTHAND HERE UNLESS IT ISN'T ALWAYS EXPANDED AT PARSE TIME (which is wrong).
     if (id == CSSPropertyFont)
         return false;
 
     return shorthandForProperty(id).length();
 }
 
 unsigned indexOfShorthandForLonghand(CSSPropertyID shorthandID, const Vector<StylePropertyShorthand>& shorthands)
 {
     for (unsigned i = 0; i < shorthands.size(); ++i) {
         if (shorthands.at(i).id() == shorthandID)
             return i;
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 } // namespace WebCore