Add consumeInteger/consumeLength

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/CSSValuePool.h"
@@ skipping 73 matching lines @@
     return cssValuePool().createValue(range.consumeIncludingWhitespace().value(), CSSPrimitiveValue::UnitType::CustomIdentifier);
 }
 
 static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeString(CSSParserTokenRange& range)
 {
     if (range.peek().type() != StringToken)
         return nullptr;
     return cssValuePool().createValue(range.consumeIncludingWhitespace().value(), CSSPrimitiveValue::UnitType::String);
 }
 
+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeNumericValue(CSSParserTokenRange& range, CSSPropertyParser::Units unitflags, CSSParserMode cssParserMode)
+{
+    CSSParserToken numericToken = range.peek();

[Timothy Loh, 2015/09/22 13:54:25]

const CSSParserToken& :-)

I really ought to make these not be copy constructible...

+    if (unitflags & CSSPropertyParser::FNonNeg && numericToken.numericValue() < 0)

[Timothy Loh, 2015/09/22 13:54:25]

numericValue() isn't set up to work for non-numeric types (i.e. not a
PercentageToken/NumberToken/DimensionToken). There's nothing really unsafe about
this, but ASAN will probably complain. Let's just check the type is numeric up
front first.

+        return nullptr;
+    bool validNumber = false;
+    switch (numericToken.unitType()) {
+    case CSSPrimitiveValue::UnitType::Number:

[Timothy Loh, 2015/09/22 13:54:25]

IMO we should do this as:

if (token.type() == NumberToken) {
} else if (token.type() == PercentageToken() {
} else { // DimensionToken
}

In particular, I'm not convinced that having unitType() do something for
non-<dimension-token>s is a good idea.

+        if (unitflags & CSSPropertyParser::FNumber) {
+            validNumber = true;
+        } else if (shouldAcceptUnitLessValues(numericToken.numericValue(), unitflags, cssParserMode)) {
+            numericToken.setUnitType((unitflags & CSSPropertyParser::FLength) ? CSSPrimitiveValue::UnitType::Pixels : CSSPrimitiveValue::UnitType::Degrees);
+            validNumber = true;
+        } else if ((unitflags & CSSPropertyParser::FInteger) && numericToken.numericValueType() == IntegerValueType) {
+            validNumber = true;
+        } else if ((unitflags & CSSPropertyParser::FPositiveInteger) && numericToken.numericValueType() == IntegerValueType && numericToken.numericValue() > 0) {
+            validNumber = true;
+        }
+        break;
+    case CSSPrimitiveValue::UnitType::Percentage:
+        validNumber = unitflags & CSSPropertyParser::FPercent;
+        break;
+    case CSSPrimitiveValue::UnitType::QuirkyEms:
+        if (cssParserMode != UASheetMode)
+            return nullptr;
+    /* fallthrough intentional */
+    case CSSPrimitiveValue::UnitType::Ems:
+    case CSSPrimitiveValue::UnitType::Rems:
+    case CSSPrimitiveValue::UnitType::Chs:
+    case CSSPrimitiveValue::UnitType::Exs:
+    case CSSPrimitiveValue::UnitType::Pixels:
+    case CSSPrimitiveValue::UnitType::Centimeters:
+    case CSSPrimitiveValue::UnitType::Millimeters:
+    case CSSPrimitiveValue::UnitType::Inches:
+    case CSSPrimitiveValue::UnitType::Points:
+    case CSSPrimitiveValue::UnitType::Picas:
+    case CSSPrimitiveValue::UnitType::ViewportWidth:
+    case CSSPrimitiveValue::UnitType::ViewportHeight:
+    case CSSPrimitiveValue::UnitType::ViewportMin:
+    case CSSPrimitiveValue::UnitType::ViewportMax:
+        validNumber = unitflags & CSSPropertyParser::FLength;
+        break;
+    case CSSPrimitiveValue::UnitType::Milliseconds:
+    case CSSPrimitiveValue::UnitType::Seconds:
+        validNumber = unitflags & CSSPropertyParser::FTime;
+        break;
+    case CSSPrimitiveValue::UnitType::Degrees:
+    case CSSPrimitiveValue::UnitType::Radians:
+    case CSSPrimitiveValue::UnitType::Gradians:
+    case CSSPrimitiveValue::UnitType::Turns:
+        validNumber = unitflags & CSSPropertyParser::FAngle;
+        break;
+    case CSSPrimitiveValue::UnitType::DotsPerPixel:
+    case CSSPrimitiveValue::UnitType::DotsPerInch:
+    case CSSPrimitiveValue::UnitType::DotsPerCentimeter:
+        validNumber = unitflags & CSSPropertyParser::FResolution;

[Timothy Loh, 2015/09/22 13:54:25]

No point adding this if we don't have any properties that use it right now.

+        break;
+    default:
+        return nullptr;
+    }
+    if (validNumber)
+        return cssValuePool().createValue(range.consumeIncludingWhitespace().numericValue(), numericToken.unitType());
+    return nullptr;
+}
+
 // Methods for consuming non-shorthand properties starts here.
 static PassRefPtrWillBeRawPtr<CSSValue> consumeWillChange(CSSParserTokenRange& range)
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
     if (range.peek().id() == CSSValueAuto) {
         // FIXME: This will be read back as an empty string instead of auto
         return values.release();
     }
 
     // Every comma-separated list of identifiers is a valid will-change value,
@@ skipping 107 matching lines @@
             break;
         default:
             return nullptr;
         }
         ligatureValues->append(consumeIdent(range));
     } while (!range.atEnd());
 
     return ligatureValues.release();
 }
 
+PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::consumeSpacing(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueNormal)
+        return consumeIdent(range);
+    return consumeNumericValue(range, FLength | FUnitlessQuirk, m_context.mode());
+}
+
 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);
     case CSSPropertyWebkitHighlight:
         return consumeWebkitHighlight(m_range);
     case CSSPropertyFontVariantLigatures:
         return consumeFontVariantLigatures(m_range);
+    case CSSPropertyLetterSpacing:
+    case CSSPropertyWordSpacing:
+        return consumeSpacing(m_range);
     default:
         return nullptr;
     }
 }
 
 bool CSSPropertyParser::parseShorthand(CSSPropertyID propId, bool important)
 {
     m_range.consumeWhitespace();
     switch (propId) {
     case CSSPropertyWebkitMarginCollapse: {
@@ skipping 33 matching lines @@
         addProperty(CSSPropertyOverflowX, overflowXValue.release(), important);
         addProperty(CSSPropertyOverflowY, overflowYValue.release(), important);
         return true;
     }
     default:
         return false;
     }
 }
 
 } // namespace blink