Move font shorthand 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"
 #include "core/css/CSSFontFeatureValue.h"
+#include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSUnicodeRangeValue.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 {
 
 CSSPropertyParser::CSSPropertyParser(CSSParserValueList* valueList, const CSSParserTokenRange& range,
     const CSSParserContext& context, WillBeHeapVector<CSSProperty, 256>& parsedProperties,
     StyleRule::Type ruleType)
     : m_valueList(valueList)
     , m_range(range)
     , m_context(context)
     , m_parsedProperties(parsedProperties)
-    , m_ruleType(ruleType)
     , m_inParseShorthand(0)
     , m_currentShorthand(CSSPropertyInvalid)
     , m_implicitShorthand(false)
 {
 }
 
 bool CSSPropertyParser::parseValue(CSSPropertyID unresolvedProperty, bool important,
     const CSSParserTokenRange& range, const CSSParserContext& context,
     WillBeHeapVector<CSSProperty, 256>& parsedProperties, StyleRule::Type ruleType)
 {
@@ skipping 454 matching lines @@
         if (fontVariant)
             values->append(fontVariant.release());
     } while (consumeCommaIncludingWhitespace(range));
 
     if (values->length())
         return values.release();
 
     return nullptr;
 }
 
-static PassRefPtrWillBeRawPtr<CSSValue> consumeFontWeight(CSSParserTokenRange& range)
+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeFontWeight(CSSParserTokenRange& range)
 {
     const CSSParserToken& token = range.peek();
     if (token.id() >= CSSValueNormal && token.id() <= CSSValueLighter)
         return consumeIdent(range);
     if (token.type() != NumberToken || token.numericValueType() != IntegerValueType)
         return nullptr;
     int weight = static_cast<int>(token.numericValue());
     if ((weight % 100) || weight < 100 || weight > 900)
         return nullptr;
     range.consumeIncludingWhitespace();
@@ skipping 61 matching lines @@
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> consumeTabSize(CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
     RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue = consumeInteger(range, cssParserMode, 0);
     if (parsedValue)
         return parsedValue;
     return consumeLength(range, cssParserMode, ValueRangeNonNegative);
 }
 
-static PassRefPtrWillBeRawPtr<CSSValue> consumeFontSize(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+static PassRefPtrWillBeRawPtr<CSSValue> consumeFontSize(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless = UnitlessQuirk::Forbid)
 {
     if (range.peek().id() >= CSSValueXxSmall && range.peek().id() <= CSSValueLarger)
         return consumeIdent(range);
-    return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
+    return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, unitless);
 }
 
 static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeLineHeight(CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
     if (range.peek().id() == CSSValueNormal)
         return consumeIdent(range);
 
     RefPtrWillBeRawPtr<CSSPrimitiveValue> lineHeight = consumeNumber(range, ValueRangeNonNegative);
     if (lineHeight)
         return lineHeight;
@@ skipping 44 matching lines @@
     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());
+        return consumeFontSize(m_range, m_context.mode(), UnitlessQuirk::Allow);
     case CSSPropertyLineHeight:
         return consumeLineHeight(m_range, m_context.mode());
     case CSSPropertyRotate:
         return consumeRotation(m_range);
     default:
         return nullptr;
     }
 }
 
 static PassRefPtrWillBeRawPtr<CSSValueList> consumeFontFaceUnicodeRange(CSSParserTokenRange& range)
@@ skipping 112 matching lines @@
         break;
     }
 
     if (!parsedValue || !m_range.atEnd())
         return false;
 
     addProperty(propId, parsedValue.release(), false);
     return true;
 }
 
+bool CSSPropertyParser::consumeSystemFont(bool important)
+{
+    CSSValueID systemFontID = m_range.consumeIncludingWhitespace().id();
+    ASSERT(systemFontID >= CSSValueCaption && systemFontID <= CSSValueStatusBar);
+    if (!m_range.atEnd())
+        return false;
+
+    FontStyle fontStyle = FontStyleNormal;
+    FontWeight fontWeight = FontWeightNormal;
+    float fontSize = 0;
+    AtomicString fontFamily;
+    LayoutTheme::theme().systemFont(systemFontID, fontStyle, fontWeight, fontSize, fontFamily);
+
+    addProperty(CSSPropertyFontStyle, cssValuePool().createIdentifierValue(fontStyle == FontStyleItalic ? CSSValueItalic : CSSValueNormal), important);
+    addProperty(CSSPropertyFontWeight, cssValuePool().createValue(fontWeight), important);
+    addProperty(CSSPropertyFontSize, cssValuePool().createValue(fontSize, CSSPrimitiveValue::UnitType::Pixels), important);
+    RefPtrWillBeRawPtr<CSSValueList> fontFamilyList = CSSValueList::createCommaSeparated();
+    fontFamilyList->append(cssValuePool().createFontFamilyValue(fontFamily));
+    addProperty(CSSPropertyFontFamily, fontFamilyList.release(), important);
+
+    addProperty(CSSPropertyFontStretch, cssValuePool().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyFontVariant, cssValuePool().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyLineHeight, cssValuePool().createIdentifierValue(CSSValueNormal), important);
+    return true;
+}
+
+bool CSSPropertyParser::consumeFont(bool important)
+{
+    // Let's check if there is an inherit or initial somewhere in the shorthand.
+    CSSParserTokenRange range = m_range;
+    while (!range.atEnd()) {
+        CSSValueID id = range.consumeIncludingWhitespace().id();
+        if (id == CSSValueInherit || id == CSSValueInitial)
+            return false;
+    }
+    // Optional font-style, font-variant, font-stretch and font-weight.
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> fontStyle = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> fontVariant = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> fontWeight = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> fontStretch = nullptr;
+    while (!m_range.atEnd()) {
+        CSSValueID id = m_range.peek().id();
+        if (!fontStyle && CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyFontStyle, id)) {
+            fontStyle = consumeIdent(m_range);
+            continue;
+        }
+        if (!fontVariant) {
+            // Font variant in the shorthand is particular, it only accepts normal or small-caps.
+            fontVariant = consumeFontVariant(m_range);
+            if (fontVariant)
+                continue;
+        }
+        if (!fontWeight) {
+            fontWeight = consumeFontWeight(m_range);
+            if (fontWeight)
+                continue;
+        }
+        if (!fontStretch && CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyFontStretch, id))
+            fontStretch = consumeIdent(m_range);
+        else
+            break;
+    }
+
+    if (m_range.atEnd())
+        return false;
+
+    addProperty(CSSPropertyFontStyle, fontStyle ? fontStyle.release() : cssValuePool().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyFontVariant, fontVariant ? fontVariant.release() : cssValuePool().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyFontWeight, fontWeight ? fontWeight.release() : cssValuePool().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyFontStretch, fontStretch ? fontStretch.release() : cssValuePool().createIdentifierValue(CSSValueNormal), important);
+
+    // Now a font size _must_ come.
+    RefPtrWillBeRawPtr<CSSValue> fontSize = consumeFontSize(m_range, m_context.mode());
+    if (!fontSize || m_range.atEnd())
+        return false;
+
+    addProperty(CSSPropertyFontSize, fontSize.release(), important);
+
+    if (m_range.peek().type() == DelimiterToken && m_range.peek().delimiter() == '/') {
+        m_range.consumeIncludingWhitespace();
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> lineHeight = consumeLineHeight(m_range, m_context.mode());
+        if (!lineHeight)
+            return false;
+        addProperty(CSSPropertyLineHeight, lineHeight.release(), important);
+    } else {
+        addProperty(CSSPropertyLineHeight, cssValuePool().createIdentifierValue(CSSValueNormal), important, true);

[Timothy Loh, 2015/10/06 23:45:04]

implicit value here can be removed too

+    }
+
+    // Font family must come now.
+    RefPtrWillBeRawPtr<CSSValue> parsedFamilyValue = consumeFontFamily(m_range);
+    if (!parsedFamilyValue)
+        return false;
+
+    addProperty(CSSPropertyFontFamily, parsedFamilyValue.release(), important);
+
+    // FIXME: http://www.w3.org/TR/2011/WD-css3-fonts-20110324/#font-prop requires that
+    // "font-stretch", "font-size-adjust", and "font-kerning" be reset to their initial values
+    // but we don't seem to support them at the moment. They should also be added here once implemented.
+    return m_range.atEnd();
+}
+
 bool CSSPropertyParser::parseShorthand(CSSPropertyID propId, bool important)
 {
     m_range.consumeWhitespace();
+    CSSPropertyID oldShorthand = m_currentShorthand;

[Timothy Loh, 2015/10/06 23:45:04]

// TODO(rob.buis): Remove this when the legacy property parser is gone

+    m_currentShorthand = propId;
     switch (propId) {
     case CSSPropertyWebkitMarginCollapse: {
         CSSValueID id = m_range.consumeIncludingWhitespace().id();
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyWebkitMarginBeforeCollapse, id))
             return false;
         RefPtrWillBeRawPtr<CSSValue> beforeCollapse = cssValuePool().createIdentifierValue(id);
         addProperty(CSSPropertyWebkitMarginBeforeCollapse, beforeCollapse, important);
         if (m_range.atEnd()) {
             addProperty(CSSPropertyWebkitMarginAfterCollapse, beforeCollapse, important);
             return true;
@@ skipping 19 matching lines @@
         // pagination controls, it should default to hidden. If the overflow-y value is anything but
         // paged-x or paged-y, then overflow-x and overflow-y should have the same value.
         if (id == CSSValueWebkitPagedX || id == CSSValueWebkitPagedY)
             overflowXValue = cssValuePool().createIdentifierValue(CSSValueAuto);
         else
             overflowXValue = overflowYValue;
         addProperty(CSSPropertyOverflowX, overflowXValue.release(), important);
         addProperty(CSSPropertyOverflowY, overflowYValue.release(), important);
         return true;
     }
+    case CSSPropertyFont: {
+        const CSSParserToken& token = m_range.peek();
+        if (token.id() >= CSSValueCaption && token.id() <= CSSValueStatusBar)
+            return consumeSystemFont(important);
+        return consumeFont(important);
+    }
     default:
+        m_currentShorthand = oldShorthand;
         return false;
     }
 }
 
 } // namespace blink