Add consumeInteger/consumeLength

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/CSSFontFaceSrcValue.h"
@@ skipping 108 matching lines @@
 
 static CSSParserTokenRange consumeFunction(CSSParserTokenRange& range)
 {
     ASSERT(range.peek().type() == FunctionToken);
     CSSParserTokenRange contents = range.consumeBlock();
     range.consumeWhitespace();
     contents.consumeWhitespace();
     return contents;
 }
 
+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeCalcExpression(const CSSParserTokenRange& range, CSSPropertyParser::Units unitflags)
+{
+    bool mustBeNonNegative = unitflags & (CSSPropertyParser::FNonNeg | CSSPropertyParser::FPositiveInteger);
+    RefPtrWillBeRawPtr<CSSCalcValue> calculation = CSSCalcValue::create(range, mustBeNonNegative ? ValueRangeNonNegative : ValueRangeAll);
+    if (!calculation)
+        return nullptr;
+    bool b = false;
+    switch (calculation->category()) {
+    case CalcLength:
+        b = (unitflags & CSSPropertyParser::FLength);
+        break;
+    case CalcNumber:
+        b = (unitflags & CSSPropertyParser::FNumber);
+        if (!b && (unitflags & (CSSPropertyParser::FInteger | CSSPropertyParser::FPositiveInteger)) && calculation->isInt())
+            b = true;
+        if (b && mustBeNonNegative && calculation->isNegative())
+            b = false;
+        // Always resolve calc() to a UnitType::Number in the CSSParserValue if there are no non-numbers specified in the unitflags.
+        if (b && !(unitflags & ~(CSSPropertyParser::FInteger | CSSPropertyParser::FNumber | CSSPropertyParser::FPositiveInteger | CSSPropertyParser::FNonNeg))) {
+            double number = calculation->doubleValue();
+            if ((unitflags & CSSPropertyParser::FPositiveInteger) && number <= 0)
+                return nullptr;
+            return cssValuePool().createValue(number, calculation->isInt() ? CSSPrimitiveValue::UnitType::Integer : CSSPrimitiveValue::UnitType::Number);
+        }
+        break;
+    case CalcPercent:
+        b = (unitflags & CSSPropertyParser::FPercent);
+        if (b && mustBeNonNegative && calculation->isNegative())
+            b = false;
+        break;
+    case CalcPercentLength:
+        b = (unitflags & CSSPropertyParser::FPercent) && (unitflags & CSSPropertyParser::FLength);
+        break;
+    case CalcPercentNumber:
+        b = (unitflags & CSSPropertyParser::FPercent) && (unitflags & CSSPropertyParser::FNumber);
+        break;
+    case CalcAngle:
+        b = (unitflags & CSSPropertyParser::FAngle);
+        break;
+    case CalcTime:
+        b = (unitflags & CSSPropertyParser::FTime);
+        break;
+    case CalcFrequency:
+        b = (unitflags & CSSPropertyParser::FFrequency);
+        break;
+    case CalcOther:
+        break;
+    }
+    if (!b)
+        return nullptr;
+    return CSSPrimitiveValue::create(calculation.release());
+}
+
+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeNumericValue(CSSParserTokenRange& range, CSSPropertyParser::Units unitflags, CSSParserMode cssParserMode)

[alancutter (OOO until 2018), 2015/09/25 04:13:06]

After discussing with timloh we decided that splitting up this switch from
valueUnit() into separate functions would make the individual call sites easier
to reason about. Currently you have to consider the entire function to determine
what the behaviour is for any given set of flags.

It could be split up into the following functions:
consumeAngle()
consumeTime()
consumeInteger(int minimum)
consumePercent(NonNeg)
consumeLength(NonNeg, UnitlessQuirks, CSSParserMode)
consumeNumber(NonNeg)
consumeLengthOrPercent(NonNeg, UnitlessQuirks, CSSParserMode)
consumeNumberOrPercent(NonNeg)

Places that currently use validUnit(FLength | FNumber) would use consumeLength()
and consumeNumber() consecutively. This makes it more obvious that it won't
accept calc(25 + 34px).

+{
+    const CSSParserToken& token = range.peek();
+    if (token.functionId() == CSSValueCalc || token.functionId() == CSSValueWebkitCalc) {
+        CSSParserTokenRange args = consumeFunction(range);

[Timothy Loh, 2015/09/25 04:44:33]

BTW this will advance the token stream for invalid calcs, which will probably
end up causing bugs later...

+        return consumeCalcExpression(args, unitflags);
+    }
+    bool validNumber = false;
+    CSSPrimitiveValue::UnitType unitType = token.unitType();
+    if (token.type() == NumberToken) {
+        if (unitflags & CSSPropertyParser::FNumber) {
+            validNumber = true;
+        } else if (shouldAcceptUnitLessValues(token.numericValue(), unitflags, cssParserMode)) {
+            unitType = (unitflags & CSSPropertyParser::FLength) ? CSSPrimitiveValue::UnitType::Pixels : CSSPrimitiveValue::UnitType::Degrees;
+            validNumber = true;
+        } else if ((unitflags & CSSPropertyParser::FInteger) && token.numericValueType() == IntegerValueType) {
+            validNumber = true;
+        } else if ((unitflags & CSSPropertyParser::FPositiveInteger) && token.numericValueType() == IntegerValueType && token.numericValue() > 0) {
+            validNumber = true;
+        }
+    } else if (token.type() == PercentageToken) {
+        validNumber = unitflags & CSSPropertyParser::FPercent;
+    } else { // DimensionToken
+        switch (token.unitType()) {
+        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;
+        default:
+            break;
+        }
+    }
+    if (validNumber) {
+        if (unitflags & CSSPropertyParser::FNonNeg && token.numericValue() < 0)
+            return nullptr;
+        return cssValuePool().createValue(range.consumeIncludingWhitespace().numericValue(), unitType);
+    }
+    return nullptr;
+}
+
 static inline bool isCSSWideKeyword(const CSSValueID& id)
 {
     return id == CSSValueInitial || id == CSSValueInherit || id == CSSValueUnset || id == CSSValueDefault;
 }
 
 // Methods for consuming non-shorthand properties starts here.
 static PassRefPtrWillBeRawPtr<CSSValue> consumeWillChange(CSSParserTokenRange& range)
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
     if (range.peek().id() == CSSValueAuto) {
@@ skipping 250 matching lines @@
             list->append(parsedValue);
         } else if ((parsedValue = consumeFamilyName(range))) {
             list->append(parsedValue);
         } else {
             return nullptr;
         }
     } while (consumeCommaIncludingWhitespace(range));
     return list.release();
 }
 
+PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::consumeSpacing()
+{
+    if (m_range.peek().id() == CSSValueNormal)
+        return consumeIdent(m_range);
+    return consumeNumericValue(m_range, FLength | FUnitlessQuirk, m_context.mode());

[Timothy Loh, 2015/09/25 04:44:33]

// TODO(rwlbuis): Don't allow unitless values, and allow <percentage>s in
word-spacing

(or mark me as the TODO owner, I don't mind)

+}
+
+PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::consumeTabSize()
+{
+    return consumeNumericValue(m_range, FInteger | FLength | FNonNeg, 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 CSSPropertyWebkitFontFeatureSettings:
         return consumeFontFeatureSettings(m_range);
     case CSSPropertyFontVariant:
         return consumeFontVariant();
     case CSSPropertyFontFamily:
         return consumeFontFamily(m_range);
     case CSSPropertyFontWeight:
         return consumeFontWeight(m_range);
+    case CSSPropertyLetterSpacing:
+    case CSSPropertyWordSpacing:
+        return consumeSpacing();
+    case CSSPropertyTabSize:
+        return consumeTabSize();
     default:
         return nullptr;
     }
 }
 
 static PassRefPtrWillBeRawPtr<CSSValueList> consumeFontFaceUnicodeRange(CSSParserTokenRange& range)
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
 
     do {
@@ skipping 152 matching lines @@
         addProperty(CSSPropertyOverflowX, overflowXValue.release(), important);
         addProperty(CSSPropertyOverflowY, overflowYValue.release(), important);
         return true;
     }
     default:
         return false;
     }
 }
 
 } // namespace blink