Simplify animation/transition parsing slightly

Source/core/css/parser/CSSPropertyParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 105 matching lines @@
 {
     ASSERT(value->unit == CSSPrimitiveValue::CSS_IDENT || value->unit == CSSPrimitiveValue::CSS_STRING);
     return equalIgnoringCase(value->string, b);
 }
 
 static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> createPrimitiveValuePair(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> first, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> second, Pair::IdenticalValuesPolicy identicalValuesPolicy = Pair::DropIdenticalValues)
 {
     return cssValuePool().createValue(Pair::create(first, second, identicalValuesPolicy));
 }
 
-class AnimationParseContext {
-public:
-    AnimationParseContext()
-        : m_animationPropertyKeywordAllowed(true)
-        , m_firstAnimationCommitted(false)
-    {
-    }
-
-    void commitFirstAnimation()
-    {
-        m_firstAnimationCommitted = true;
-    }
-
-    bool hasCommittedFirstAnimation() const
-    {
-        return m_firstAnimationCommitted;
-    }
-
-    void commitAnimationPropertyKeyword()
-    {
-        m_animationPropertyKeywordAllowed = false;
-    }
-
-    bool animationPropertyKeywordAllowed() const
-    {
-        return m_animationPropertyKeywordAllowed;
-    }
-
-private:
-    bool m_animationPropertyKeywordAllowed;
-    bool m_firstAnimationCommitted;
-};
-
 CSSPropertyParser::CSSPropertyParser(OwnPtr<CSSParserValueList>& valueList,
     const CSSParserContext& context, bool inViewport, bool savedImportant,
     WillBeHeapVector<CSSProperty, 256>& parsedProperties,
     CSSRuleSourceData::Type ruleType)
     : m_valueList(valueList)
     , m_context(context)
     , m_inViewport(inViewport)
     , m_important(savedImportant) // See comment in header, should be removed.
     , m_parsedProperties(parsedProperties)
     , m_ruleType(ruleType)
@@ skipping 1045 matching lines @@
     case CSSPropertyWebkitAnimationIterationCount:
     case CSSPropertyWebkitAnimationTimingFunction:
     case CSSPropertyTransitionDelay:
     case CSSPropertyTransitionDuration:
     case CSSPropertyTransitionTimingFunction:
     case CSSPropertyTransitionProperty:
     case CSSPropertyWebkitTransitionDelay:
     case CSSPropertyWebkitTransitionDuration:
     case CSSPropertyWebkitTransitionTimingFunction:
     case CSSPropertyWebkitTransitionProperty: {
-        RefPtrWillBeRawPtr<CSSValue> val = nullptr;
-        AnimationParseContext context;
-        if (parseAnimationProperty(propId, val, context)) {
+        if (RefPtrWillBeRawPtr<CSSValueList> val = parseAnimationPropertyList(propId)) {
             addPropertyWithPrefixingVariant(propId, val.release(), important);
             return true;
         }
         return false;
     }
 
     case CSSPropertyJustifySelf:
         if (!RuntimeEnabledFeatures::cssGridLayoutEnabled())
             return false;
 
@@ skipping 603 matching lines @@
         if (properties[i] == CSSPropertyBackgroundOrigin && !foundClip)
             addProperty(CSSPropertyBackgroundClip, clipValue.release(), important);
         else if (properties[i] == CSSPropertyWebkitMaskOrigin && !foundClip)
             addProperty(CSSPropertyWebkitMaskClip, clipValue.release(), important);
     }
 
     m_implicitShorthand = false;
     return true;
 }
 
-void CSSPropertyParser::addAnimationValue(RefPtrWillBeRawPtr<CSSValue>& lval, PassRefPtrWillBeRawPtr<CSSValue> rval)
+static bool isValidTransitionPropertyList(CSSValueList* value)
 {
-    if (lval) {
-        if (lval->isValueList())
-            toCSSValueList(lval.get())->append(rval);
-        else {
-            PassRefPtrWillBeRawPtr<CSSValue> oldVal(lval.release());
-            PassRefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
-            list->append(oldVal);
-            list->append(rval);
-            lval = list;
-        }
+    if (value->length() < 2)
+        return true;
+    for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
+        // FIXME: Shorthand parsing shouldn't add initial to the list since it won't round-trip
+        if (i.value()->isInitialValue())
+            continue;
+        CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(i.value());
+        if (primitiveValue->isValueID() && primitiveValue->getValueID() == CSSValueNone)
+            return false;
     }
-    else
-        lval = rval;
+    return true;
 }
 
 bool CSSPropertyParser::parseAnimationShorthand(CSSPropertyID propId, bool important)
 {
     const StylePropertyShorthand& animationProperties = parsingShorthandForProperty(propId);
     const unsigned numProperties = 8;
 
     // The list of properties in the shorthand should be the same
     // length as the list with animation name in last position, even though they are
     // in a different order.
     ASSERT(numProperties == animationProperties.length());
     ASSERT(numProperties == shorthandForProperty(propId).length());
 
     ShorthandScope scope(this, propId);
 
     bool parsedProperty[numProperties] = { false };
-    AnimationParseContext context;
-    RefPtrWillBeRawPtr<CSSValue> values[numProperties];
-#if ENABLE(OILPAN)
-    // Zero initialize the array of raw pointers.
-    memset(&values, 0, sizeof(values));
-#endif
+    RefPtrWillBeRawPtr<CSSValueList> values[numProperties];
+    for (size_t i = 0; i < numProperties; ++i)
+        values[i] = CSSValueList::createCommaSeparated();
 
-    unsigned i;
     while (m_valueList->current()) {
         CSSParserValue* val = m_valueList->current();
         if (val->unit == CSSParserValue::Operator && val->iValue == ',') {
-            // We hit the end.  Fill in all remaining values with the initial value.
+            // We hit the end. Fill in all remaining values with the initial value.
             m_valueList->next();
-            for (i = 0; i < numProperties; ++i) {
+            for (size_t i = 0; i < numProperties; ++i) {
                 if (!parsedProperty[i])
-                    addAnimationValue(values[i], cssValuePool().createImplicitInitialValue());
+                    values[i]->append(cssValuePool().createImplicitInitialValue());
                 parsedProperty[i] = false;
             }
             if (!m_valueList->current())
                 break;
-            context.commitFirstAnimation();
         }
 
         bool found = false;
-        for (i = 0; i < numProperties; ++i) {
-            if (!parsedProperty[i]) {
-                RefPtrWillBeRawPtr<CSSValue> val = nullptr;
-                if (parseAnimationProperty(animationProperties.properties()[i], val, context)) {
-                    parsedProperty[i] = found = true;
-                    addAnimationValue(values[i], val.release());
-                    break;
-                }
+        for (size_t i = 0; i < numProperties; ++i) {
+            if (parsedProperty[i])
+                continue;
+            if (RefPtrWillBeRawPtr<CSSValue> val = parseAnimationProperty(animationProperties.properties()[i])) {
+                parsedProperty[i] = found = true;
+                values[i]->append(val.release());
+                break;
             }
         }
 
         // if we didn't find at least one match, this is an
         // invalid shorthand and we have to ignore it
         if (!found)
             return false;
     }
 
-    for (i = 0; i < numProperties; ++i) {
+    for (size_t i = 0; i < numProperties; ++i) {
         // If we didn't find the property, set an intial value.
         if (!parsedProperty[i])
-            addAnimationValue(values[i], cssValuePool().createImplicitInitialValue());
+            values[i]->append(cssValuePool().createImplicitInitialValue());
 
         if (RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled())
             addPropertyWithPrefixingVariant(animationProperties.properties()[i], values[i].release(), important);
         else
             addProperty(animationProperties.properties()[i], values[i].release(), important);
     }
 
     return true;
 }
 
 bool CSSPropertyParser::parseTransitionShorthand(CSSPropertyID propId, bool important)
 {
     const unsigned numProperties = 4;
     const StylePropertyShorthand& shorthand = shorthandForProperty(propId);
     ASSERT(numProperties == shorthand.length());
 
     ShorthandScope scope(this, propId);
 
     bool parsedProperty[numProperties] = { false };
-    AnimationParseContext context;
-    RefPtrWillBeRawPtr<CSSValue> values[numProperties];
-#if ENABLE(OILPAN)
-    // Zero initialize the array of raw pointers.
-    memset(&values, 0, sizeof(values));
-#endif
+    RefPtrWillBeRawPtr<CSSValueList> values[numProperties];
+    for (size_t i = 0; i < numProperties; ++i)
+        values[i] = CSSValueList::createCommaSeparated();
 
-    unsigned i;
     while (m_valueList->current()) {
         CSSParserValue* val = m_valueList->current();
         if (val->unit == CSSParserValue::Operator && val->iValue == ',') {
             // We hit the end. Fill in all remaining values with the initial value.
             m_valueList->next();
-            for (i = 0; i < numProperties; ++i) {
+            for (size_t i = 0; i < numProperties; ++i) {
                 if (!parsedProperty[i])
-                    addAnimationValue(values[i], cssValuePool().createImplicitInitialValue());
+                    values[i]->append(cssValuePool().createImplicitInitialValue());
                 parsedProperty[i] = false;
             }
             if (!m_valueList->current())
                 break;
-            context.commitFirstAnimation();
         }
 
         bool found = false;
-        for (i = 0; !found && i < numProperties; ++i) {
-            if (!parsedProperty[i]) {
-                RefPtrWillBeRawPtr<CSSValue> val = nullptr;
-                if (parseAnimationProperty(shorthand.properties()[i], val, context)) {
-                    parsedProperty[i] = found = true;
-                    addAnimationValue(values[i], val.release());
-                }
-
-                // There are more values to process but 'none' or 'all' were already defined as the animation property, the declaration becomes invalid.
-                if (!context.animationPropertyKeywordAllowed() && context.hasCommittedFirstAnimation())
-                    return false;
+        for (size_t i = 0; i < numProperties; ++i) {
+            if (parsedProperty[i])
+                continue;
+            if (RefPtrWillBeRawPtr<CSSValue> val = parseAnimationProperty(shorthand.properties()[i])) {
+                parsedProperty[i] = found = true;
+                values[i]->append(val.release());
+                break;
             }
         }
 
         // if we didn't find at least one match, this is an
         // invalid shorthand and we have to ignore it
         if (!found)
             return false;
     }
 
-    // Fill in any remaining properties with the initial value.
-    for (i = 0; i < numProperties; ++i) {
+    ASSERT(shorthand.properties()[0] == CSSPropertyTransitionProperty || shorthand.properties()[0] == CSSPropertyWebkitTransitionProperty);
+    if (!isValidTransitionPropertyList(values[0].get()))
+        return false;
+
+    // Fill in any remaining properties with the initial value and add
+    for (size_t i = 0; i < numProperties; ++i) {
         if (!parsedProperty[i])
-            addAnimationValue(values[i], cssValuePool().createImplicitInitialValue());
+            values[i]->append(cssValuePool().createImplicitInitialValue());
+        addPropertyWithPrefixingVariant(shorthand.properties()[i], values[i].release(), important);
     }
 
-    // Now add all of the properties we found.
-    for (i = 0; i < numProperties; i++)
-        addPropertyWithPrefixingVariant(shorthand.properties()[i], values[i].release(), important);
-
     return true;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseColumnWidth()
 {
     CSSParserValue* value = m_valueList->current();
     // Always parse lengths in strict mode here, since it would be ambiguous otherwise when used in
     // the 'columns' shorthand property.
     if (value->id == CSSValueAuto
         || (validUnit(value, FLength | FNonNeg, HTMLStandardMode) && value->fValue)) {
@@ skipping 1103 matching lines @@
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationPlayState()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueRunning || value->id == CSSValuePaused)
         return cssValuePool().createIdentifierValue(value->id);
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationProperty(AnimationParseContext& context)
+PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationProperty()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->unit != CSSPrimitiveValue::CSS_IDENT)
         return nullptr;
     CSSPropertyID result = cssPropertyID(value->string);
     if (result && RuntimeCSSEnabled::isCSSPropertyEnabled(result))
         return cssValuePool().createIdentifierValue(result);
     if (equalIgnoringCase(value, "all"))
         return cssValuePool().createIdentifierValue(CSSValueAll);
-    if (equalIgnoringCase(value, "none")) {
-        context.commitAnimationPropertyKeyword();
+    if (equalIgnoringCase(value, "none"))
         return cssValuePool().createIdentifierValue(CSSValueNone);
-    }
     return nullptr;
 }
 
 bool CSSPropertyParser::parseWebkitTransformOriginShorthand(RefPtrWillBeRawPtr<CSSValue>& value1, RefPtrWillBeRawPtr<CSSValue>& value2, RefPtrWillBeRawPtr<CSSValue>& value3)
 {
     parse2ValuesFillPosition(m_valueList.get(), value1, value2);
 
     // now get z
     if (m_valueList->current()) {
         if (validUnit(m_valueList->current(), FLength)) {
@@ skipping 99 matching lines @@
             return nullptr;
         if (!parseCubicBezierTimingFunctionValue(args, y2))
             return nullptr;
 
         return CSSCubicBezierTimingFunctionValue::create(x1, y1, x2, y2);
     }
 
     return nullptr;
 }
 
-bool CSSPropertyParser::parseAnimationProperty(CSSPropertyID propId, RefPtrWillBeRawPtr<CSSValue>& result, AnimationParseContext& context)
+PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationProperty(CSSPropertyID propId)
 {
-    RefPtrWillBeRawPtr<CSSValueList> values = nullptr;
-    CSSParserValue* val;
     RefPtrWillBeRawPtr<CSSValue> value = nullptr;
-    bool allowComma = false;
-
-    result = nullptr;
-
-    while ((val = m_valueList->current())) {
-        RefPtrWillBeRawPtr<CSSValue> currValue = nullptr;
-        if (allowComma) {
-            if (!isComma(val))
-                return false;
-            m_valueList->next();
-            allowComma = false;
-        }
-        else {
-            switch (propId) {
-                case CSSPropertyAnimationDelay:
-                case CSSPropertyWebkitAnimationDelay:
-                case CSSPropertyTransitionDelay:
-                case CSSPropertyWebkitTransitionDelay:
-                    currValue = parseAnimationDelay();
-                    if (currValue)
-                        m_valueList->next();
-                    break;
-                case CSSPropertyAnimationDirection:
-                case CSSPropertyWebkitAnimationDirection:
-                    currValue = parseAnimationDirection();
-                    if (currValue)
-                        m_valueList->next();
-                    break;
-                case CSSPropertyAnimationDuration:
-                case CSSPropertyWebkitAnimationDuration:
-                case CSSPropertyTransitionDuration:
-                case CSSPropertyWebkitTransitionDuration:
-                    currValue = parseAnimationDuration();
-                    if (currValue)
-                        m_valueList->next();
-                    break;
-                case CSSPropertyAnimationFillMode:
-                case CSSPropertyWebkitAnimationFillMode:
-                    currValue = parseAnimationFillMode();
-                    if (currValue)
-                        m_valueList->next();
-                    break;
-                case CSSPropertyAnimationIterationCount:
-                case CSSPropertyWebkitAnimationIterationCount:
-                    currValue = parseAnimationIterationCount();
-                    if (currValue)
-                        m_valueList->next();
-                    break;
-                case CSSPropertyAnimationName:
-                case CSSPropertyWebkitAnimationName:
-                    currValue = parseAnimationName();
-                    if (currValue)
-                        m_valueList->next();
-                    break;
-                case CSSPropertyAnimationPlayState:
-                case CSSPropertyWebkitAnimationPlayState:
-                    currValue = parseAnimationPlayState();
-                    if (currValue)
-                        m_valueList->next();
-                    break;
-                case CSSPropertyTransitionProperty:
-                case CSSPropertyWebkitTransitionProperty:
-                    currValue = parseAnimationProperty(context);
-                    if (value && !context.animationPropertyKeywordAllowed())
-                        return false;
-                    if (currValue)
-                        m_valueList->next();
-                    break;
-                case CSSPropertyAnimationTimingFunction:
-                case CSSPropertyWebkitAnimationTimingFunction:
-                case CSSPropertyTransitionTimingFunction:
-                case CSSPropertyWebkitTransitionTimingFunction:
-                    currValue = parseAnimationTimingFunction();
-                    if (currValue)
-                        m_valueList->next();
-                    break;
-                default:
-                    ASSERT_NOT_REACHED();
-                    return false;
-            }
-
-            if (!currValue)
-                return false;
-
-            if (value && !values) {
-                values = CSSValueList::createCommaSeparated();
-                values->append(value.release());
-            }
-
-            if (values)
-                values->append(currValue.release());
-            else
-                value = currValue.release();
-
-            allowComma = true;
-        }
-
-        // When parsing the 'transition' shorthand property, we let it handle building up the lists for all
-        // properties.
-        if (inShorthand())
-            break;
+    switch (propId) {
+    case CSSPropertyAnimationDelay:
+    case CSSPropertyWebkitAnimationDelay:
+    case CSSPropertyTransitionDelay:
+    case CSSPropertyWebkitTransitionDelay:
+        value = parseAnimationDelay();
+        break;
+    case CSSPropertyAnimationDirection:
+    case CSSPropertyWebkitAnimationDirection:
+        value = parseAnimationDirection();
+        break;
+    case CSSPropertyAnimationDuration:
+    case CSSPropertyWebkitAnimationDuration:
+    case CSSPropertyTransitionDuration:
+    case CSSPropertyWebkitTransitionDuration:
+        value = parseAnimationDuration();
+        break;
+    case CSSPropertyAnimationFillMode:
+    case CSSPropertyWebkitAnimationFillMode:
+        value = parseAnimationFillMode();
+        break;
+    case CSSPropertyAnimationIterationCount:
+    case CSSPropertyWebkitAnimationIterationCount:
+        value = parseAnimationIterationCount();
+        break;
+    case CSSPropertyAnimationName:
+    case CSSPropertyWebkitAnimationName:
+        value = parseAnimationName();
+        break;
+    case CSSPropertyAnimationPlayState:
+    case CSSPropertyWebkitAnimationPlayState:
+        value = parseAnimationPlayState();
+        break;
+    case CSSPropertyTransitionProperty:
+    case CSSPropertyWebkitTransitionProperty:
+        value = parseAnimationProperty();
+        break;
+    case CSSPropertyAnimationTimingFunction:
+    case CSSPropertyWebkitAnimationTimingFunction:
+    case CSSPropertyTransitionTimingFunction:
+    case CSSPropertyWebkitTransitionTimingFunction:
+        value = parseAnimationTimingFunction();
+        break;
+    default:
+        ASSERT_NOT_REACHED();
+        return nullptr;
     }
 
-    if (values && values->length()) {
-        result = values.release();
-        return true;
+    if (value)
+        m_valueList->next();
+    return value.release();
+}
+
+PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseAnimationPropertyList(CSSPropertyID propId)
+{
+    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    while (m_valueList->current()) {
+        RefPtrWillBeRawPtr<CSSValue> value = parseAnimationProperty(propId);
+        if (!value)
+            return nullptr;
+        list->append(value.release());
+        if (CSSParserValue* parserValue = m_valueList->current()) {
+            if (!isComma(parserValue))
+                return nullptr;
+            m_valueList->next();
+            ASSERT(m_valueList->current());
+        }
     }
-    if (value) {
-        result = value.release();
-        return true;
-    }
-    return false;
+    if ((propId == CSSPropertyTransitionProperty || propId == CSSPropertyWebkitTransitionProperty) && !isValidTransitionPropertyList(list.get()))
+        return nullptr;
+    ASSERT(list->length());
+    return list.release();
 }
 
 static inline bool isCSSWideKeyword(CSSParserValue& value)
 {
     return value.id == CSSValueInitial || value.id == CSSValueInherit || value.id == CSSValueDefault;
 }
 
 static inline bool isValidCustomIdentForGridPositions(CSSParserValue& value)
 {
     // FIXME: we need a more general solution for <custom-ident> in all properties.
@@ skipping 5131 matching lines @@
         parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueFill));
     if (!seenStroke)
         parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueStroke));
     if (!seenMarkers)
         parsedValues->append(CSSPrimitiveValue::createIdentifier(CSSValueMarkers));
 
     return parsedValues.release();
 }
 
 } // namespace WebCore