Move grid-auto-column/grid-auto-row into CSSPropertyParser

third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/CSSBorderImage.h"
 #include "core/css/CSSContentDistributionValue.h"
@@ skipping 3048 matching lines @@
     if (spanValue)
         values->append(spanValue.release());
     if (numericValue)
         values->append(numericValue.release());
     if (gridLineName)
         values->append(gridLineName.release());
     ASSERT(values->length());
     return values.release();
 }
 
+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeGridBreadth(CSSParserTokenRange& range, CSSParserMode cssParserMode, TrackSizeRestriction restriction = AllowAll)
+{
+    const CSSParserToken& token = range.peek();
+    if (identMatches<CSSValueMinContent, CSSValueMaxContent, CSSValueAuto>(token.id()))

[Timothy Loh, 2016/03/22 06:33:59]

Maybe nicer if we check the restriction first?

if (restriction == AllowAll) {
    ...
}
return consumeLengthOrPercent();

[rwlbuis, 2016/03/22 20:48:12]

Done.

+        return restriction == AllowAll ? consumeIdent(range) : nullptr;
+
+    if (token.type() == DimensionToken && token.unitType() == CSSPrimitiveValue::UnitType::Fraction) {
+        if (restriction == FixedSizeOnly)
+            return nullptr;
+        double flexValue = range.consumeIncludingWhitespace().numericValue();

[Timothy Loh, 2016/03/22 06:33:59]

Probably should finish validating before consuming so we don't update the range
and then return nullptr

[rwlbuis, 2016/03/22 20:48:12]

Done.

+        // Fractional unit is a non-negative dimension.
+        if (flexValue < 0)
+            return nullptr;
+        return cssValuePool().createValue(flexValue, CSSPrimitiveValue::UnitType::Fraction);
+    }
+    return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
+}
+
+static PassRefPtrWillBeRawPtr<CSSValue> consumeGridTrackSize(CSSParserTokenRange& range, CSSParserMode cssParserMode, TrackSizeRestriction restriction = AllowAll)
+{
+    const CSSParserToken& token = range.peek();
+    if (identMatches<CSSValueAuto>(token.id()))

[Timothy Loh, 2016/03/22 06:33:59]

IMO clearer to not use a ternary and just write

if (restriction == AllowAll && identMatches..)

[rwlbuis, 2016/03/22 20:48:12]

Done.

+        return restriction == AllowAll ? consumeIdent(range) : nullptr;
+
+    if (token.functionId() == CSSValueMinmax) {
+        // The spec defines the following grammar: minmax( <track-breadth> , <track-breadth> ).

[Timothy Loh, 2016/03/22 06:33:59]

Comment isn't very useful imo

[rwlbuis, 2016/03/22 20:48:12]

Done.

+        CSSParserTokenRange args = consumeFunction(range);

[Timothy Loh, 2016/03/22 06:33:59]

Should we make a copy of the range? If the arguments are invalid we'd end up
still consuming the minmax() function and the "[ <line-names>? <string>
<track-size>? <line-names>? ]+ [ / <track-list> ]?" case of grid will be neater
if this function doesn't do that.

[rwlbuis, 2016/03/22 20:48:12]

Done.

+        RefPtrWillBeRawPtr<CSSPrimitiveValue> minTrackBreadth = consumeGridBreadth(args, cssParserMode, restriction);
+        if (!minTrackBreadth || !consumeCommaIncludingWhitespace(args))
+            return nullptr;
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> maxTrackBreadth = consumeGridBreadth(args, cssParserMode);
+        if (!maxTrackBreadth || !args.atEnd())
+            return nullptr;
+        RefPtrWillBeRawPtr<CSSFunctionValue> result = CSSFunctionValue::create(CSSValueMinmax);
+        result->append(minTrackBreadth.release());
+        result->append(maxTrackBreadth.release());
+        return result.release();
+    }
+    return consumeGridBreadth(range, cssParserMode, restriction);
+}
+
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID unresolvedProperty)
 {
     CSSPropertyID property = resolveCSSPropertyID(unresolvedProperty);
     if (CSSParserFastPaths::isKeywordPropertyID(property)) {
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(property, m_range.peek().id()))
             return nullptr;
         return consumeIdent(m_range);
     }
     switch (property) {
     case CSSPropertyWillChange:
@@ skipping 348 matching lines @@
         return consumeSelfPositionOverflowPosition(m_range);
     case CSSPropertyJustifyItems:
         ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
         return consumeJustifyItems(m_range);
     case CSSPropertyGridColumnEnd:
     case CSSPropertyGridColumnStart:
     case CSSPropertyGridRowEnd:
     case CSSPropertyGridRowStart:
         ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
         return consumeGridLine(m_range);
+    case CSSPropertyGridAutoColumns:
+    case CSSPropertyGridAutoRows:
+        ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
+        return consumeGridTrackSize(m_range, m_context.mode());
     default:
         CSSParserValueList valueList(m_range);
         if (valueList.size()) {
             m_valueList = &valueList;
             if (RefPtrWillBeRawPtr<CSSValue> result = legacyParseValue(unresolvedProperty)) {
                 while (!m_range.atEnd())
                     m_range.consume();
                 return result.release();
             }
         }
@@ skipping 993 matching lines @@
         m_currentShorthand = oldShorthand;
         CSSParserValueList valueList(m_range);
         if (!valueList.size())
             return false;
         m_valueList = &valueList;
         return legacyParseShorthand(unresolvedProperty, important);
     }
 }
 
 } // namespace blink