[CSS Grid Layout] Implementation of the grid-template shorthand.

Source/core/css/parser/BisonCSSParser-in.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 2470 matching lines @@
         if (!RuntimeEnabledFeatures::cssGridLayoutEnabled())
             return false;
         return parseGridAreaShorthand(important);
 
     case CSSPropertyGridTemplateAreas:
         if (!RuntimeEnabledFeatures::cssGridLayoutEnabled())
             return false;
         parsedValue = parseGridTemplateAreas();
         break;
 
+    case CSSPropertyGridTemplate:
+        if (!RuntimeEnabledFeatures::cssGridLayoutEnabled())
+            return false;
+        return parseGridTemplateShorthand(important);
+
     case CSSPropertyWebkitMarginCollapse: {
         if (num == 1) {
             ShorthandScope scope(this, CSSPropertyWebkitMarginCollapse);
             if (!parseValue(webkitMarginCollapseShorthand().properties()[0], important))
                 return false;
             CSSValue* value = m_parsedProperties.last().value();
             addProperty(webkitMarginCollapseShorthand().properties()[1], value, important);
             return true;
         }
         else if (num == 2) {
@@ skipping 2210 matching lines @@
             return false;
     } else {
         endValue = gridMissingGridPositionValue(startValue.get());
     }
 
     addProperty(shorthand.properties()[0], startValue, important);
     addProperty(shorthand.properties()[1], endValue, important);
     return true;
 }
 
+bool BisonCSSParser::parseGridTemplateRowsAndAreas(bool important)
+{
+    NamedGridAreaMap gridAreaMap;
+    size_t rowCount = 0;
+    size_t columnCount = 0;
+    bool traillingAdded = false;
+    RefPtr<CSSValueList> templateRows = CSSValueList::createSpaceSeparated();
+    CSSParserValue* currentValue = m_valueList->current();
+
+    // There must be either template-areas or template-rows.
+    if (!currentValue)
+        return false;
+
+    do {
+        // Handle leading/trailling <ident>*.
+        if (currentValue->unit == CSSParserValue::ValueList)
+            parseGridLineNames(m_valueList.get(), *templateRows, traillingAdded);
+
+        // Handle a template-area's row.
+        if (parseGridTemplateAreasRow(gridAreaMap, rowCount, columnCount))
+            ++rowCount;
+
+        // If no template-areas, template-rows must be defined.
+        if (!((currentValue = m_valueList->current()) || rowCount))
+            return false;
+
+        // Handle template-rows's track-size.
+        if (currentValue && currentValue->unit != CSSParserValue::ValueList) {
+            RefPtr<CSSValue> value = parseGridTrackSize(*m_valueList);
+            if (!(value || rowCount))
+                return false;
+            templateRows->append(value);
+        } else {
+            templateRows->append(cssValuePool().createIdentifierValue(CSSValueAuto));
+        }
+
+        // This will handle the trailing <ident>* in the grammar.
+        traillingAdded = false;
+        if (m_valueList->current() && m_valueList->current()->unit == CSSParserValue::ValueList) {
+            parseGridLineNames(m_valueList.get(), *templateRows);
+            traillingAdded = true;
+        }
+    } while ((currentValue = m_valueList->current()));
+
+    if (!templateRows->length())
+        addProperty(CSSPropertyGridTemplateRows, cssValuePool().createIdentifierValue(CSSValueNone), important);
+    else
+        addProperty(CSSPropertyGridTemplateRows, templateRows.release(), important);
+    if (!rowCount) {
+        addProperty(CSSPropertyGridTemplateAreas, cssValuePool().createIdentifierValue(CSSValueNone), important);
+    } else {
+        RefPtr<CSSValue> templateAreas = CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
+        addProperty(CSSPropertyGridTemplateAreas, templateAreas.release(), important);
+    }
+
+    return true;
+}
+
+bool BisonCSSParser::parseGridTemplateShorthand(bool important)
+{
+    ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
+
+    ShorthandScope scope(this, CSSPropertyGridTemplate);
+    const StylePropertyShorthand& shorthand = gridTemplateShorthand();
+    ASSERT_UNUSED(shorthand, shorthand.length() == 3);
+
+    RefPtr<CSSValue> columnsValue = cssValuePool().createIdentifierValue(CSSValueNone);
+    RefPtr<CSSValue> rowsValue = cssValuePool().createIdentifierValue(CSSValueNone);
+    RefPtr<CSSValue> areasValue = cssValuePool().createIdentifierValue(CSSValueNone);
+
+    RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
+    CSSParserValue* current = m_valueList->current();
+
+    if (!current)
+        return false;

[svillar, 2014/02/07 12:02:49]

Better do this before creating all the above objects.

BTW maybe it's better not to initialize them to none since you're likely going
to replace those values later. We can just check if they're null when adding the
properties at the very end.

+
+    NamedGridAreaMap gridAreaMap;
+    size_t rowCount = 0;
+    size_t columnCount = 0;
+    bool forwardOp = false;

[svillar, 2014/02/07 12:02:49]

Use a more descriptive name like seenForwardSlashOperator.

+    bool traillingAdded = false;

[svillar, 2014/02/07 12:02:49]

trailing. Also traillingAdded is a very confusing name, I don't know what it
means unless I check the code.

+    bool simpleForm = true; // template-columns / template-rows

[svillar, 2014/02/07 12:02:49]

Use a more descriptive name for this variable, we need to know that it refers to
a grid-template without areas. After that remove the comment :)

+    do {
+        if (isForwardSlashOperator(current)) {
+            if (forwardOp)
+                return false; // Slash not allowed in the second clause.
+            if (!values->length())
+                return false; // First clause is mandatory.
+            if (!(current = m_valueList->next()))
+                return false; // Second clause is mandatory.

[svillar, 2014/02/07 12:02:49]

I guess you could put these three in a single row

+            forwardOp = true;
+            columnsValue = values.release();
+            values = CSSValueList::createSpaceSeparated();
+        }
+
+        // Handle leading/trailling <ident>*.

[svillar, 2014/02/07 12:02:49]

trailing

+        if (current->unit == CSSParserValue::ValueList) {
+            if (traillingAdded && simpleForm) // Not allowed in simple form.
+                return false;
+            parseGridLineNames(m_valueList.get(), *values, traillingAdded);
+            if (!(current = m_valueList->current()))
+                break;
+        }
+
+        // Handle a template-area's row.
+        if (current->unit == CSSPrimitiveValue::CSS_STRING) {
+            if (!parseGridTemplateAreasRow(gridAreaMap, rowCount, columnCount))
+                return false;
+            ++rowCount;
+            simpleForm = false;
+            if (!(current = m_valueList->current()))
+                break;
+        }
+
+        // Handle template-{columns/rows}'s track-size, repeat or auto.
+        if (current->unit == CSSParserValue::Function && equalIgnoringCase(current->function->name, "repeat(")) {
+            if (!simpleForm)
+                return false; // Not allowed for template-row in complex form.
+            if (!parseGridTrackRepeatFunction(*values))
+                return false;
+        } else if (current->unit != CSSParserValue::ValueList) {
+            RefPtr<CSSValue> value = parseGridTrackSize(*m_valueList);
+            if (!value && simpleForm) // Mandatory in template-columns, "auto" in 2nd form template-rows.
+                return false;
+            values->append(value);
+        } else {
+            if (simpleForm)
+                return false; // track-size mandatory in template-columns
+            values->append(cssValuePool().createIdentifierValue(CSSValueAuto));
+        }
+
+        if (!(current = m_valueList->current()))
+            break;
+
+        // This will handle the trailing <ident>* in the grammar.
+        traillingAdded = false;
+        if (current && current->unit == CSSParserValue::ValueList) {
+            parseGridLineNames(m_valueList.get(), *values);
+            traillingAdded = true;
+            current = m_valueList->current();
+        }
+    } while ((current = m_valueList->current()));
+
+    if (rowCount)
+        areasValue = CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
+
+    if (forwardOp) {
+        if (values->length() > 0)
+            rowsValue = values;
+    } else {
+        if (simpleForm)
+            return false; // 2 mandatory clauses in simple form.

[svillar, 2014/02/07 12:02:49]

It looks like this should be an ASSERT but haven't checked the above algorithm
carefully enough to know if it guarantees that.

+        if (values->length() > 0)
+            columnsValue = values;
+    }
+
+    addProperty(CSSPropertyGridTemplateColumns, columnsValue, important);
+    addProperty(CSSPropertyGridTemplateRows, rowsValue, important);
+    addProperty(CSSPropertyGridTemplateAreas, areasValue, important);
+
+    return true;
+}
+
 bool BisonCSSParser::parseGridAreaShorthand(bool important)
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     ShorthandScope scope(this, CSSPropertyGridArea);
     const StylePropertyShorthand& shorthand = gridAreaShorthand();
     ASSERT_UNUSED(shorthand, shorthand.length() == 4);
 
     RefPtr<CSSValue> rowStartValue = parseGridPosition();
     if (!rowStartValue)
@@ skipping 35 matching lines @@
     if (!isForwardSlashOperator(m_valueList->current()))
         return false;
 
     if (!m_valueList->next())
         return false;
 
     property = parseGridPosition();
     return true;
 }
 
-void BisonCSSParser::parseGridLineNames(CSSParserValueList* parserValueList, CSSValueList& valueList)
+void BisonCSSParser::parseGridLineNames(CSSParserValueList* parserValueList, CSSValueList& valueList, bool concat)
 {
     ASSERT(parserValueList->current() && parserValueList->current()->unit == CSSParserValue::ValueList);
 
     CSSParserValueList* identList = parserValueList->current()->valueList;
     if (!identList->size()) {
         parserValueList->next();
         return;
     }
 
-    RefPtr<CSSGridLineNamesValue> lineNames = CSSGridLineNamesValue::create();
+    RefPtr<CSSGridLineNamesValue> lineNames = concat && valueList.length() > 0 ? static_cast< CSSGridLineNamesValue* >(valueList.item(valueList.length() - 1)) : CSSGridLineNamesValue::create();
     while (CSSParserValue* identValue = identList->current()) {
         ASSERT(identValue->unit == CSSPrimitiveValue::CSS_IDENT);
         RefPtr<CSSPrimitiveValue> lineName = createPrimitiveStringValue(identValue);
         lineNames->append(lineName.release());
         identList->next();
     }
-    valueList.append(lineNames.release());
+    if (!concat)
+        valueList.append(lineNames.release());
 

[svillar, 2014/02/07 12:02:49]

So instead of doing this, I think it's better to pass a CSSGridLineNamesValue&
instead of a CSSValueList&. That way this function will always do the same
thing. The caller is the one that will either create a new CSSGridLineNamesValue
instance or just pass a reference to an already existing one.

     parserValueList->next();
 }
 
 bool BisonCSSParser::parseGridTrackList(CSSPropertyID propId, bool important)
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueNone) {
         if (m_valueList->next())
@@ skipping 123 matching lines @@
 
         return cssValuePool().createValue(flexValue, CSSPrimitiveValue::CSS_FR);
     }
 
     if (!validUnit(currentValue, FNonNeg | FLength | FPercent))
         return 0;
 
     return createPrimitiveNumericValue(currentValue);
 }
 
+bool BisonCSSParser::parseGridTemplateAreasRow(NamedGridAreaMap& gridAreaMap, const size_t rowCount, size_t& columnCount)
+{
+    CSSParserValue* currentValue = m_valueList->current();
+    if (!currentValue || currentValue->unit != CSSPrimitiveValue::CSS_STRING)
+        return false;
+
+    String gridRowNames = currentValue->string;
+    if (!gridRowNames.length())
+        return false;
+
+    Vector<String> columnNames;
+    gridRowNames.split(' ', columnNames);
+
+    if (!columnCount) {
+        columnCount = columnNames.size();
+        ASSERT(columnCount);
+    } else if (columnCount != columnNames.size()) {
+        // The declaration is invalid is all the rows don't have the number of columns.
+        return false;
+    }
+
+    for (size_t currentCol = 0; currentCol < columnCount; ++currentCol) {
+        const String& gridAreaName = columnNames[currentCol];
+
+        // Unamed areas are always valid (we consider them to be 1x1).
+        if (gridAreaName == ".")
+            continue;
+
+        // We handle several grid areas with the same name at once to simplify the validation code.
+        size_t lookAheadCol;
+        for (lookAheadCol = currentCol; lookAheadCol < (columnCount - 1); ++lookAheadCol) {
+            if (columnNames[lookAheadCol + 1] != gridAreaName)
+                break;
+        }
+
+        NamedGridAreaMap::iterator gridAreaIt = gridAreaMap.find(gridAreaName);
+        if (gridAreaIt == gridAreaMap.end()) {
+            gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan(rowCount, rowCount), GridSpan(currentCol, lookAheadCol)));
+        } else {
+            GridCoordinate& gridCoordinate = gridAreaIt->value;
+
+            // The following checks test that the grid area is a single filled-in rectangle.
+            // 1. The new row is adjacent to the previously parsed row.
+            if (rowCount != gridCoordinate.rows.initialPositionIndex + 1)
+                return false;
+
+            // 2. The new area starts at the same position as the previously parsed area.
+            if (currentCol != gridCoordinate.columns.initialPositionIndex)
+                return false;
+
+            // 3. The new area ends at the same position as the previously parsed area.
+            if (lookAheadCol != gridCoordinate.columns.finalPositionIndex)
+                return false;
+
+            ++gridCoordinate.rows.finalPositionIndex;
+        }
+        currentCol = lookAheadCol;
+    }
+
+    m_valueList->next();
+    return true;
+}
+
 PassRefPtr<CSSValue> BisonCSSParser::parseGridTemplateAreas()
 {
     NamedGridAreaMap gridAreaMap;
     size_t rowCount = 0;
     size_t columnCount = 0;
 
-    while (CSSParserValue* currentValue = m_valueList->current()) {
-        if (currentValue->unit != CSSPrimitiveValue::CSS_STRING)
+    while (m_valueList->current()) {
+        if (!parseGridTemplateAreasRow(gridAreaMap, rowCount, columnCount))
             return 0;
-
-        String gridRowNames = currentValue->string;
-        if (!gridRowNames.length())
-            return 0;
-
-        Vector<String> columnNames;
-        gridRowNames.split(' ', columnNames);
-
-        if (!columnCount) {
-            columnCount = columnNames.size();
-            ASSERT(columnCount);
-        } else if (columnCount != columnNames.size()) {
-            // The declaration is invalid is all the rows don't have the number of columns.
-            return 0;
-        }
-
-        for (size_t currentCol = 0; currentCol < columnCount; ++currentCol) {
-            const String& gridAreaName = columnNames[currentCol];
-
-            // Unamed areas are always valid (we consider them to be 1x1).
-            if (gridAreaName == ".")
-                continue;
-
-            // We handle several grid areas with the same name at once to simplify the validation code.
-            size_t lookAheadCol;
-            for (lookAheadCol = currentCol; lookAheadCol < (columnCount - 1); ++lookAheadCol) {
-                if (columnNames[lookAheadCol + 1] != gridAreaName)
-                    break;
-            }
-
-            NamedGridAreaMap::iterator gridAreaIt = gridAreaMap.find(gridAreaName);
-            if (gridAreaIt == gridAreaMap.end()) {
-                gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan(rowCount, rowCount), GridSpan(currentCol, lookAheadCol)));
-            } else {
-                GridCoordinate& gridCoordinate = gridAreaIt->value;
-
-                // The following checks test that the grid area is a single filled-in rectangle.
-                // 1. The new row is adjacent to the previously parsed row.
-                if (rowCount != gridCoordinate.rows.initialPositionIndex + 1)
-                    return 0;
-
-                // 2. The new area starts at the same position as the previously parsed area.
-                if (currentCol != gridCoordinate.columns.initialPositionIndex)
-                    return 0;
-
-                // 3. The new area ends at the same position as the previously parsed area.
-                if (lookAheadCol != gridCoordinate.columns.finalPositionIndex)
-                    return 0;
-
-                ++gridCoordinate.rows.finalPositionIndex;
-            }
-            currentCol = lookAheadCol;
-        }
-
         ++rowCount;
-        m_valueList->next();
     }
 
     if (!rowCount || !columnCount)
         return 0;
 
     return CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
 }
 
 PassRefPtr<CSSValue> BisonCSSParser::parseCounterContent(CSSParserValueList* args, bool counters)
 {
@@ skipping 5281 matching lines @@
 {
     // The tokenizer checks for the construct of an+b.
     // However, since the {ident} rule precedes the {nth} rule, some of those
     // tokens are identified as string literal. Furthermore we need to accept
     // "odd" and "even" which does not match to an+b.
     return equalIgnoringCase(token, "odd") || equalIgnoringCase(token, "even")
         || equalIgnoringCase(token, "n") || equalIgnoringCase(token, "-n");
 }
 
 }