[CSS Grid Layout] Update grid-auto-flow to the new syntax

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 1179 matching lines @@
             return true;
         }
         return false;
     }
 
     case CSSPropertyJustifySelf:
         if (!RuntimeEnabledFeatures::cssGridLayoutEnabled())
             return false;
 
         return parseItemPositionOverflowPosition(propId, important);
+    case CSSPropertyGridAutoFlow:
+        if (!RuntimeEnabledFeatures::cssGridLayoutEnabled())
+            return false;
+        parsedValue = parseGridAutoFlow(*m_valueList);
+        break;
     case CSSPropertyGridAutoColumns:
     case CSSPropertyGridAutoRows:
         if (!RuntimeEnabledFeatures::cssGridLayoutEnabled())
             return false;
         parsedValue = parseGridTrackSize(*m_valueList);
         break;
 
     case CSSPropertyGridTemplateColumns:
     case CSSPropertyGridTemplateRows:
         if (!RuntimeEnabledFeatures::cssGridLayoutEnabled())
@@ skipping 353 matching lines @@
     case CSSPropertyWebkitColumnBreakBefore:
     case CSSPropertyWebkitColumnBreakInside:
     case CSSPropertyColumnFill:
     case CSSPropertyWebkitColumnRuleStyle:
     case CSSPropertyAlignContent:
     case CSSPropertyFlexDirection:
     case CSSPropertyFlexWrap:
     case CSSPropertyJustifyContent:
     case CSSPropertyFontKerning:
     case CSSPropertyWebkitFontSmoothing:
-    case CSSPropertyGridAutoFlow:
     case CSSPropertyWebkitLineBreak:
     case CSSPropertyWebkitMarginAfterCollapse:
     case CSSPropertyWebkitMarginBeforeCollapse:
     case CSSPropertyWebkitMarginBottomCollapse:
     case CSSPropertyWebkitMarginTopCollapse:
     case CSSPropertyInternalMarqueeDirection:
     case CSSPropertyInternalMarqueeStyle:
     case CSSPropertyWebkitPrintColorAdjust:
     case CSSPropertyWebkitRtlOrdering:
     case CSSPropertyWebkitRubyPosition:
@@ skipping 36 matching lines @@
     default:
         return parseSVGValue(propId, important);
     }
 
     if (validPrimitive) {
         parsedValue = parseValidPrimitive(id, value);
         m_valueList->next();
     }
     ASSERT(!m_parsedCalculation);
     if (parsedValue) {
         if (!m_valueList->current() || inShorthand()) {

[Manuel Rego, 2014/06/27 22:43:51]

This line makes that things like "column foo" are consider as invalid.
Basically, if there's some value pending to be parsed, only if we're in a
shorthand
it'll return true, otherwise it'll return false.

             addProperty(propId, parsedValue.release(), important);
             return true;
         }
     }
     return false;
 }
 
 void CSSPropertyParser::addFillValue(RefPtrWillBeRawPtr<CSSValue>& lval, PassRefPtrWillBeRawPtr<CSSValue> rval)
 {
     if (lval) {
@@ skipping 1905 matching lines @@
         addProperty(CSSPropertyGridAutoFlow, cssValuePool().createImplicitInitialValue(), important);
         addProperty(CSSPropertyGridAutoColumns, cssValuePool().createImplicitInitialValue(), important);
         addProperty(CSSPropertyGridAutoRows, cssValuePool().createImplicitInitialValue(), important);
         return true;
     }
 
     // Need to rewind parsing to explore the alternative syntax of this shorthand.
     m_valueList->setCurrentIndex(0);
 
     // 2- <grid-auto-flow> [ <grid-auto-columns> [ / <grid-auto-rows> ]? ]
-    CSSValueID id = m_valueList->current()->id;
-    if (id != CSSValueRow && id != CSSValueColumn && id != CSSValueNone)
+    if (!parseValue(CSSPropertyGridAutoFlow, important))
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> autoFlowValue = cssValuePool().createIdentifierValue(id);
     RefPtrWillBeRawPtr<CSSValue> autoColumnsValue = nullptr;
     RefPtrWillBeRawPtr<CSSValue> autoRowsValue = nullptr;
 
-    if (m_valueList->next()) {
+    if (m_valueList->current()) {
         autoColumnsValue = parseGridTrackSize(*m_valueList);
         if (!autoColumnsValue)
             return false;
         if (m_valueList->current()) {
             if (!isForwardSlashOperator(m_valueList->current()) || !m_valueList->next())
                 return false;
             autoRowsValue = parseGridTrackSize(*m_valueList);
             if (!autoRowsValue)
                 return false;
         }
         if (m_valueList->current())
             return false;
     } else {
         // Other omitted values are set to their initial values.
         autoColumnsValue = cssValuePool().createImplicitInitialValue();
         autoRowsValue = cssValuePool().createImplicitInitialValue();
     }
 
     // if <grid-auto-rows> value is omitted, it is set to the value specified for grid-auto-columns.
     if (!autoRowsValue)
         autoRowsValue = autoColumnsValue;
 
-    addProperty(CSSPropertyGridAutoFlow, autoFlowValue, important);
     addProperty(CSSPropertyGridAutoColumns, autoColumnsValue, important);
     addProperty(CSSPropertyGridAutoRows, autoRowsValue, important);
 
     // It can only be specified the explicit or the implicit grid properties in a single grid declaration.
     // The sub-properties not specified are set to their initial value, as normal for shorthands.
     addProperty(CSSPropertyGridTemplateColumns, cssValuePool().createImplicitInitialValue(), important);
     addProperty(CSSPropertyGridTemplateRows, cssValuePool().createImplicitInitialValue(), important);
     addProperty(CSSPropertyGridTemplateAreas, cssValuePool().createImplicitInitialValue(), important);
 
     return true;
@@ skipping 299 matching lines @@
             return nullptr;
         ++rowCount;
     }
 
     if (!rowCount || !columnCount)
         return nullptr;
 
     return CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
 }
 
+PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseGridAutoFlow(CSSParserValueList& list)
+{
+    // [ row | column ] && dense? | stack && [ row | column ]?
+    ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
+
+    CSSParserValue* value = list.current();
+    if (!value)
+        return nullptr;
+
+    RefPtrWillBeRawPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
+
+    // First parameter.
+    CSSValueID firstId = value->id;
+    if (value->id != CSSValueRow && value->id != CSSValueColumn && value->id != CSSValueDense && value->id != CSSValueStack)

[Julien - ping for review, 2014/06/27 17:44:53]

Nit: firstId->id !=

[Manuel Rego, 2014/06/27 22:43:51]

Yeah, I changed value->id by firstId.

+        return nullptr;
+    parsedValues->append(cssValuePool().createIdentifierValue(value->id));
+
+    // Second parameter, if any.
+    value = list.next();
+    if (!value && firstId == CSSValueDense)
+        return nullptr;
+
+    if (value) {
+        switch (firstId) {
+        case CSSValueRow:
+        case CSSValueColumn:
+            if (value->id != CSSValueDense && value->id != CSSValueStack)
+                return parsedValues;

[Julien - ping for review, 2014/06/27 17:44:53]

I assume this is needed for the 'grid' shorthand but won't this risk allowing
anything for 'grid-auto-flow' (I couldn't find any testing for "row foo" as an
invalid value)

[Manuel Rego, 2014/06/27 22:43:51]

I had one "column column" that was an invalid value.
I've added now a "column foo" and it's already being detected as invalid value.

As explained before the reason is the if at the end of
CSSPropertyParser::parseValue().

+            break;
+        case CSSValueDense:
+        case CSSValueStack:
+            if (value->id != CSSValueRow && value->id != CSSValueColumn)
+                return parsedValues;

[Julien - ping for review, 2014/06/27 17:44:53]

Same comment.

+            break;
+        default:
+            return parsedValues;
+        }
+        parsedValues->append(cssValuePool().createIdentifierValue(value->id));
+        list.next();
+    }
+
+    return parsedValues;
+}
+
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseCounterContent(CSSParserValueList* args, bool counters)
 {
     unsigned numArgs = args->size();
     if (counters && numArgs != 3 && numArgs != 5)
         return nullptr;
     if (!counters && numArgs != 1 && numArgs != 3)
         return nullptr;
 
     CSSParserValue* i = args->current();
     if (i->unit != CSSPrimitiveValue::CSS_IDENT)
@@ skipping 4514 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