Move counter-increment/counter-reset handling 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 "config.h"
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSFontFaceSrcValue.h"
 #include "core/css/CSSFontFeatureValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSStringValue.h"
 #include "core/css/CSSURIValue.h"
 #include "core/css/CSSUnicodeRangeValue.h"
+#include "core/css/CSSValuePair.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/FontFace.h"
 #include "core/css/parser/CSSParserFastPaths.h"
 #include "core/css/parser/CSSParserValues.h"
 #include "core/frame/UseCounter.h"
 #include "core/layout/LayoutTheme.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
@@ skipping 134 matching lines @@
         CSSPrimitiveValue::UnitType unitType = m_calcValue->isInt() ? CSSPrimitiveValue::UnitType::Integer : CSSPrimitiveValue::UnitType::Number;
         return cssValuePool().createValue(m_calcValue->doubleValue(), unitType);
     }
 
 private:
     CSSParserTokenRange& m_sourceRange;
     CSSParserTokenRange m_range;
     RefPtrWillBeMember<CSSCalcValue> m_calcValue;
 };
 
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeInteger(CSSParserTokenRange& range, CSSParserMode cssParserMode, double minimumValue = std::numeric_limits<int>::min())
+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeInteger(CSSParserTokenRange& range, CSSParserMode cssParserMode, double minimumValue = std::numeric_limits<int>::lowest())
 {
     const CSSParserToken& token = range.peek();
     if (token.type() == NumberToken) {
         if (token.numericValueType() == NumberValueType || token.numericValue() < minimumValue)
             return nullptr;
         return cssValuePool().createValue(range.consumeIncludingWhitespace().numericValue(), token.unitType());
     }
     CalcParser calcParser(range);
     if (const CSSCalcValue* calculation = calcParser.value()) {
         if (calculation->category() != CalcNumber || !calculation->isInt())
@@ skipping 439 matching lines @@
     for (unsigned i = 0; i < 3; i++) { // 3 dimensions of rotation
         RefPtrWillBeRawPtr<CSSValue> dimension = consumeNumber(range, ValueRangeAll);
         if (!dimension)
             return nullptr;
         list->append(dimension.release());
     }
 
     return list.release();
 }
 
+static PassRefPtrWillBeRawPtr<CSSValue> consumeCounter(CSSParserTokenRange& range, CSSParserMode cssParserMode, int defaultValue)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+
+    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

[Timothy Loh, 2015/10/08 23:13:56]

TODO to create a space-separated value list here :-)

+    do {
+        if (range.peek().type() != IdentToken)

[Timothy Loh, 2015/10/08 23:13:56]

btw I'd prefer this as follows

RefPtr..<CSSCustomIdentValue> counterName = consumeCustomIdent(range);
if (!counterName)
    return nullptr;

So this way type checking is the responsibility of the consume helper, and
there's no change we accidentally check the type incorrectly and then make a
counter with a null counter name.

+            return nullptr;
+        RefPtrWillBeRawPtr<CSSCustomIdentValue> counterName = consumeCustomIdent(range);
+        int i = defaultValue;
+        if (RefPtrWillBeRawPtr<CSSPrimitiveValue> counterValue = consumeInteger(range, cssParserMode, std::numeric_limits<double>::lowest()))

[Timothy Loh, 2015/10/08 23:13:56]

How about (don't need to pass in the limit if it's a default arg):

RefPtrWillBeRawPtr<CSSPrimitiveValue> counterValue = consumeInteger(range,
cssParserMode);
if (!counterValue)
    counterValue = ..create(defaultValue)

[rwlbuis, 2015/10/09 02:31:12]

Sorry, should have mentioned the s/min/lowest change. In the past I assumed min
did what lowest actually does...
IIRC going with <int>::lowest rather than <double>::lowest causes some test
failure, will double check tomorrow.

+            i = clampTo<int>(counterValue->getDoubleValue());
+        list->append(CSSValuePair::create(counterName.release(),
+            cssValuePool().createValue(i, CSSPrimitiveValue::UnitType::Number),
+            CSSValuePair::DropIdenticalValues));
+    } while (!range.atEnd());
+    return list.release();
+}
+
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID propId)
 {
     m_range.consumeWhitespace();
     switch (propId) {
     case CSSPropertyWillChange:
         return consumeWillChange(m_range);
     case CSSPropertyPage:
         return consumePage(m_range);
     case CSSPropertyQuotes:
         return consumeQuotes(m_range);
@@ skipping 16 matching lines @@
         return consumeTabSize(m_range, m_context.mode());
     case CSSPropertyFontSize:
         return consumeFontSize(m_range, m_context.mode(), UnitlessQuirk::Allow);
     case CSSPropertyLineHeight:
         return consumeLineHeight(m_range, m_context.mode());
     case CSSPropertyRotate:
         return consumeRotation(m_range);
     case CSSPropertyWebkitBorderHorizontalSpacing:
     case CSSPropertyWebkitBorderVerticalSpacing:
         return consumeLength(m_range, m_context.mode(), ValueRangeNonNegative);
+    case CSSPropertyCounterIncrement:
+    case CSSPropertyCounterReset:
+        return consumeCounter(m_range, m_context.mode(), propId == CSSPropertyCounterIncrement ? 1 : 0);
     default:
         return nullptr;
     }
 }
 
 static PassRefPtrWillBeRawPtr<CSSValueList> consumeFontFaceUnicodeRange(CSSParserTokenRange& range)
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
 
     do {
@@ skipping 284 matching lines @@
     }
     case CSSPropertyBorderSpacing:
         return consumeBorderSpacing(important);
     default:
         m_currentShorthand = oldShorthand;
         return false;
     }
 }
 
 } // namespace blink