Move line-height property 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/CSSFontFaceSrcValue.h"
@@ skipping 165 matching lines @@
         if (calculation->category() != CalcNumber || !calculation->isInt())
             return nullptr;
         double value = calculation->doubleValue();
         if (value < minimumValue)
             return nullptr;
         return calcParser.consumeNumber();
     }
     return nullptr;
 }
 
+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeNumber(CSSParserTokenRange& range, ValueRange valueRange)
+{
+    const CSSParserToken& token = range.peek();
+    if (token.type() == NumberToken) {
+        if (valueRange == ValueRangeNonNegative && token.numericValue() < 0)
+            return nullptr;
+        return cssValuePool().createValue(range.consumeIncludingWhitespace().numericValue(), token.unitType());
+    }
+    CalcParser calcParser(range, ValueRangeAll);
+    if (const CSSCalcValue* calculation = calcParser.value()) {
+        if (calculation->category() != CalcNumber || (valueRange == ValueRangeNonNegative && calculation->isNegative()))

[alancutter (OOO until 2018), 2015/10/02 01:54:10]

I don't think calcs should be subject to parse time range checks at all
according to the spec: https://drafts.csswg.org/css-values-3/#calc-range
Altering this would be changing behaviour in a refactor patch though so perhaps
just add a TODO with the spec link to remove this check.

+            return nullptr;
+        return calcParser.consumeValue();
+    }
+    return nullptr;
+}
+
 inline bool shouldAcceptUnitlessValues(double fValue, CSSParserMode cssParserMode, UnitlessQuirk unitless)
 {
     // Quirks mode for certain properties and presentation attributes accept unit-less values for certain units.
     return !fValue // 0 can always be unitless.
         || isUnitLessLengthParsingEnabledForMode(cssParserMode) // HTML and SVG attribute values can always be unitless.
         || (cssParserMode == HTMLQuirksMode && (unitless == UnitlessQuirk::Allow));
 }
 
 static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeLength(CSSParserTokenRange& range, CSSParserMode cssParserMode, ValueRange valueRange, UnitlessQuirk unitless = UnitlessQuirk::Forbid)
 {
@@ skipping 49 matching lines @@
         return cssValuePool().createValue(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::Percentage);
     }
     CalcParser calcParser(range, valueRange);
     if (const CSSCalcValue* calculation = calcParser.value()) {
         if (calculation->category() == CalcLength || calculation->category() == CalcPercent || calculation->category() == CalcPercentLength)
             return calcParser.consumeValue();
     }
     return nullptr;
 }
 
+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeNumberOrPercent(CSSParserTokenRange& range, ValueRange valueRange)
+{
+    const CSSParserToken& token = range.peek();
+    if (token.type() == NumberToken)
+        return consumeNumber(range, valueRange);
+    if (token.type() == PercentageToken) {
+        if (valueRange == ValueRangeNonNegative && token.numericValue() < 0)
+            return nullptr;
+        return cssValuePool().createValue(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::Percentage);
+    }
+    CalcParser calcParser(range, valueRange);
+    if (const CSSCalcValue* calculation = calcParser.value()) {
+        if (!(calculation->category() == CalcNumber || calculation->category() == CalcPercent || calculation->category() == CalcPercentNumber))
+            return nullptr;
+        if (valueRange == ValueRangeNonNegative && calculation->isNegative())
+            return nullptr;
+        return calcParser.consumeValue();
+    }
+    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 273 matching lines @@
     return consumeLength(range, cssParserMode, ValueRangeNonNegative);
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> consumeFontSize(CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
     if (range.peek().id() >= CSSValueXxSmall && range.peek().id() <= CSSValueLarger)
         return consumeIdent(range);
     return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
 }
 
+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeLineHeight(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (range.peek().id() == CSSValueNormal)
+        return consumeIdent(range);
+
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue = consumeNumberOrPercent(range, ValueRangeNonNegative);
+    if (!parsedValue)
+        parsedValue = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
+
+    // The line-height property can accept both percents and numbers but additive opertaions are
+    // not permitted on them in calc() expressions.
+    if (parsedValue && parsedValue->isCalculatedPercentageWithNumber())
+        return nullptr;
+
+    return parsedValue.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);
     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(m_range, m_context.mode());
     case CSSPropertyTabSize:
         return consumeTabSize(m_range, m_context.mode());
     case CSSPropertyFontSize:
         return consumeFontSize(m_range, m_context.mode());
+    case CSSPropertyLineHeight:
+        return consumeLineHeight(m_range, m_context.mode());
     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