Move parseFontFaceDescriptor to CSSPropertyParser.cpp

Source/core/css/parser/LegacyCSSPropertyParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 17 matching lines @@
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSBasicShapes.h"
 #include "core/css/CSSBorderImage.h"
 #include "core/css/CSSCanvasValue.h"
 #include "core/css/CSSContentDistributionValue.h"
 #include "core/css/CSSCounterValue.h"
 #include "core/css/CSSCrossfadeValue.h"
 #include "core/css/CSSCursorImageValue.h"
-#include "core/css/CSSFontFaceSrcValue.h"
-#include "core/css/CSSFontFeatureValue.h"
 #include "core/css/CSSFunctionValue.h"
 #include "core/css/CSSGridLineNamesValue.h"
 #include "core/css/CSSImageSetValue.h"
 #include "core/css/CSSImageValue.h"
 #include "core/css/CSSPathValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSProperty.h"
 #include "core/css/CSSPropertyMetadata.h"
 #include "core/css/CSSQuadValue.h"
 #include "core/css/CSSReflectValue.h"
 #include "core/css/CSSSVGDocumentValue.h"
 #include "core/css/CSSShadowValue.h"
 #include "core/css/CSSTimingFunctionValue.h"
-#include "core/css/CSSUnicodeRangeValue.h"
 #include "core/css/CSSValuePair.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/HashTools.h"
 #include "core/css/parser/CSSParserFastPaths.h"
 #include "core/css/parser/CSSParserValues.h"
 #include "core/frame/UseCounter.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/style/GridCoordinate.h"
 #include "core/svg/SVGPathUtilities.h"
 #include "platform/RuntimeEnabledFeatures.h"
@@ skipping 676 matching lines @@
     case CSSPropertyWebkitMinLogicalWidth:
     case CSSPropertyWebkitMinLogicalHeight:
     case CSSPropertyWebkitLogicalWidth:
     case CSSPropertyWebkitLogicalHeight:
         validPrimitive = (id == CSSValueAuto || validWidthOrHeight(value, unitless));
         break;
 
     case CSSPropertyFontSize:
         return parseFontSize(important);
 
-    case CSSPropertyFontVariant:         // normal | small-caps | inherit
-        return parseFontVariant(important);
-
     case CSSPropertyVerticalAlign:
         // baseline | sub | super | top | text-top | middle | bottom | text-bottom |
         // <percentage> | <length> | inherit
 
         if (id >= CSSValueBaseline && id <= CSSValueWebkitBaselineMiddle)
             validPrimitive = true;
         else
             validPrimitive = validUnit(value, FLength | FPercent | FUnitlessQuirk);
         break;
 
@@ skipping 42 matching lines @@
             validPrimitive = true;
         else
             parsedValue = parseCounter(1);
         break;
     case CSSPropertyCounterReset:
         if (id == CSSValueNone)
             validPrimitive = true;
         else
             parsedValue = parseCounter(0);
         break;
-    case CSSPropertyFontFamily:
-        // [[ <family-name> | <generic-family> ],]* [<family-name> | <generic-family>] | inherit
-    {
-        parsedValue = parseFontFamily();
-        break;
-    }
 
     case CSSPropertyTextDecoration:
         // Fall through 'text-decoration-line' parsing if CSS 3 Text Decoration
         // is disabled to match CSS 2.1 rules for parsing 'text-decoration'.
         if (RuntimeEnabledFeatures::css3TextDecorationsEnabled()) {
             // [ <text-decoration-line> || <text-decoration-style> || <text-decoration-color> ] | inherit
             return parseShorthand(CSSPropertyTextDecoration, textDecorationShorthand(), important);
         }
     case CSSPropertyWebkitTextDecorationsInEffect:
     case CSSPropertyTextDecorationLine:
@@ skipping 537 matching lines @@
     case CSSPropertyWebkitTextEmphasisStyle:
         parsedValue = parseTextEmphasisStyle();
         break;
 
     case CSSPropertyWebkitTextOrientation:
         // FIXME: For now just support sideways, sideways-right, upright and vertical-right.
         if (id == CSSValueSideways || id == CSSValueSidewaysRight || id == CSSValueVerticalRight || id == CSSValueUpright)
             validPrimitive = true;
         break;
 
-    case CSSPropertyWebkitFontFeatureSettings:
-        if (id == CSSValueNormal)
-            validPrimitive = true;
-        else
-            parsedValue = parseFontFeatureSettings();
-        break;
-
-    case CSSPropertyFontVariantLigatures:
-        if (id == CSSValueNormal)
-            validPrimitive = true;
-        else
-            return parseFontVariantLigatures(important);
-        break;
     case CSSPropertyWebkitClipPath:
         if (id == CSSValueNone) {
             validPrimitive = true;
         } else if (value->m_unit == CSSParserValue::Function) {
             parsedValue = parseBasicShape();
         } else if (value->unit() == CSSPrimitiveValue::UnitType::URI) {
             parsedValue = CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::UnitType::URI);
             addProperty(propId, parsedValue.release(), important);
             return true;
         }
@@ skipping 37 matching lines @@
         validPrimitive = false;
         break;
 
     // These were not accepted by the new path above so we should return false.
     case CSSPropertyWebkitMarginCollapse:
     case CSSPropertyWillChange:
     case CSSPropertyPage:
     case CSSPropertyOverflow:
     case CSSPropertyQuotes:
     case CSSPropertyWebkitHighlight:
+    case CSSPropertyFontVariantLigatures:
+    case CSSPropertyWebkitFontFeatureSettings:
+    case CSSPropertyFontVariant:
+    case CSSPropertyFontFamily:
         validPrimitive = false;
         break;
 
     case CSSPropertyScrollSnapPointsX:
     case CSSPropertyScrollSnapPointsY:
         parsedValue = parseScrollSnapPoints();
         break;
     case CSSPropertyScrollSnapCoordinate:
         parsedValue = parseScrollSnapCoordinate();
         break;
@@ skipping 3060 matching lines @@
     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;
 }
 
-class FontFamilyValueBuilder {
-    STACK_ALLOCATED();
-public:
-    FontFamilyValueBuilder(CSSValueList* list)
-        : m_list(list)
-    {
-    }
-
-    void add(const CSSParserString& string)
-    {
-        if (!m_builder.isEmpty())
-            m_builder.append(' ');
-
-        if (string.is8Bit()) {
-            m_builder.append(string.characters8(), string.length());
-            return;
-        }
-
-        m_builder.append(string.characters16(), string.length());
-    }
-
-    void commit()
-    {
-        if (m_builder.isEmpty())
-            return;
-        m_list->append(cssValuePool().createFontFamilyValue(m_builder.toString()));
-        m_builder.clear();
-    }
-
-private:
-    StringBuilder m_builder;
-    RawPtrWillBeMember<CSSValueList> m_list;
-};
-
 PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseFontFamily()
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
     CSSParserValue* value = m_valueList->current();
 
     FontFamilyValueBuilder familyBuilder(list.get());
     bool inFamily = false;
 
     while (value) {
         CSSParserValue* nextValue = m_valueList->next();
@@ skipping 89 matching lines @@
     // <absolute-size> | <relative-size> | <length> | <percentage> | inherit
     if (id >= CSSValueXxSmall && id <= CSSValueLarger)
         validPrimitive = true;
     else
         validPrimitive = validUnit(value, FLength | FPercent | FNonNeg | (inShorthand() ? FUnknown : FUnitlessQuirk));
     if (validPrimitive && (!m_valueList->next() || inShorthand()))
         addProperty(CSSPropertyFontSize, parseValidPrimitive(id, value), important);
     return validPrimitive;
 }
 
-bool CSSPropertyParser::parseFontVariant(bool important)
-{
-    RefPtrWillBeRawPtr<CSSValueList> values = nullptr;
-    if (m_valueList->size() > 1)
-        values = CSSValueList::createCommaSeparated();
-    bool expectComma = false;
-    for (CSSParserValue* val = m_valueList->current(); val; val = m_valueList->current()) {
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue = nullptr;
-        if (!expectComma) {
-            expectComma = true;
-            if (val->id == CSSValueNormal || val->id == CSSValueSmallCaps)
-                parsedValue = cssValuePool().createIdentifierValue(val->id);
-            else if (val->id == CSSValueAll && !values) {
-                // FIXME: CSSPropertyParser::parseFontVariant() implements
-                // the old css3 draft:
-                // http://www.w3.org/TR/2002/WD-css3-webfonts-20020802/#font-variant
-                // 'all' is only allowed in @font-face and with no other values. Make a value list to
-                // indicate that we are in the @font-face case.
-                values = CSSValueList::createCommaSeparated();
-                parsedValue = cssValuePool().createIdentifierValue(val->id);
-            }
-        } else if (consumeComma(m_valueList)) {
-            expectComma = false;
-            continue;
-        }
-
-        if (!parsedValue)
-            return false;
-
-        m_valueList->next();
-
-        if (values)
-            values->append(parsedValue.release());
-        else {
-            addProperty(CSSPropertyFontVariant, parsedValue.release(), important);
-            return true;
-        }
-    }
-
-    if (values && values->length()) {
-        if (m_ruleType != StyleRule::FontFace)
-            return false;
-        addProperty(CSSPropertyFontVariant, values.release(), important);
-        return true;
-    }
-
-    return false;
-}
-
 bool CSSPropertyParser::parseFontWeight(bool important)
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id >= CSSValueNormal && value->id <= CSSValueLighter) {
         addProperty(CSSPropertyFontWeight, cssValuePool().createIdentifierValue(value->id), important);
         return true;
     }
     if (value->unit() == CSSPrimitiveValue::UnitType::Number) {
         int weight = static_cast<int>(value->fValue);
         if (!(weight % 100) && weight >= 100 && weight <= 900) {
             addProperty(CSSPropertyFontWeight, cssValuePool().createIdentifierValue(static_cast<CSSValueID>(CSSValue100 + weight / 100 - 1)), important);
             return true;
         }
     }
     return false;
 }
 
-bool CSSPropertyParser::parseFontFaceSrcURI(CSSValueList* valueList)
-{
-    RefPtrWillBeRawPtr<CSSFontFaceSrcValue> uriValue(CSSFontFaceSrcValue::create(completeURL(m_valueList->current()->string), m_context.shouldCheckContentSecurityPolicy()));
-    uriValue->setReferrer(m_context.referrer());
-
-    CSSParserValue* value = m_valueList->next();
-    if (!value || value->m_unit != CSSParserValue::Function || value->function->id != CSSValueFormat) {
-        valueList->append(uriValue.release());
-        return true;
-    }
-
-    // FIXME: http://www.w3.org/TR/2011/WD-css3-fonts-20111004/ says that format() contains a comma-separated list of strings,
-    // but CSSFontFaceSrcValue stores only one format. Allowing one format for now.
-    CSSParserValueList* args = value->function->args.get();
-    if (!args || args->size() != 1 || (args->current()->unit() != CSSPrimitiveValue::UnitType::String && args->current()->m_unit != CSSParserValue::Identifier))
-        return false;
-    uriValue->setFormat(args->current()->string);
-    valueList->append(uriValue.release());
-    m_valueList->next();
-    return true;
-}
-
-bool CSSPropertyParser::parseFontFaceSrcLocal(CSSValueList* valueList)
-{
-    CSSParserValueList* args = m_valueList->current()->function->args.get();
-    if (!args || !args->size())
-        return false;
-    m_valueList->next();
-
-    ContentSecurityPolicyDisposition shouldCheckContentSecurityPolicy = m_context.shouldCheckContentSecurityPolicy();
-    if (args->size() == 1 && args->current()->unit() == CSSPrimitiveValue::UnitType::String) {
-        valueList->append(CSSFontFaceSrcValue::createLocal(args->current()->string, shouldCheckContentSecurityPolicy));
-    } else if (args->current()->m_unit == CSSParserValue::Identifier) {
-        StringBuilder builder;
-        for (CSSParserValue* localValue = args->current(); localValue; localValue = args->next()) {
-            if (localValue->m_unit != CSSParserValue::Identifier)
-                return false;
-            if (!builder.isEmpty())
-                builder.append(' ');
-            builder.append(localValue->string);
-        }
-        valueList->append(CSSFontFaceSrcValue::createLocal(builder.toString(), shouldCheckContentSecurityPolicy));
-    } else
-        return false;
-
-    return true;
-}
-
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseFontFaceSrc()
-{
-    RefPtrWillBeRawPtr<CSSValueList> values(CSSValueList::createCommaSeparated());
-
-    while (true) {
-        CSSParserValue* value = m_valueList->current();
-        if (!value)
-            return nullptr;
-        if (value->unit() == CSSPrimitiveValue::UnitType::URI) {
-            if (!parseFontFaceSrcURI(values.get()))
-                return nullptr;
-        } else if (value->m_unit == CSSParserValue::Function && value->function->id == CSSValueLocal) {
-            if (!parseFontFaceSrcLocal(values.get()))
-                return nullptr;
-        } else {
-            return nullptr;
-        }
-
-        if (!m_valueList->current())
-            return values.release();
-        if (!consumeComma(m_valueList))
-            return nullptr;
-    }
-}
-
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseFontFaceUnicodeRange()
-{
-    RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
-
-    do {
-        CSSParserValue* current = m_valueList->current();
-        if (!current || current->m_unit != CSSParserValue::UnicodeRange)
-            return nullptr;
-
-        UChar32 start = current->m_unicodeRange.start;
-        UChar32 end = current->m_unicodeRange.end;
-        if (start > end)
-            return nullptr;
-        values->append(CSSUnicodeRangeValue::create(start, end));
-        m_valueList->next();
-    } while (consumeComma(m_valueList));
-
-    return values.release();
-}
-
 inline int CSSPropertyParser::colorIntFromValue(CSSParserValue* v)
 {
     bool isPercent;
     double value;
 
     if (m_parsedCalculation) {
         isPercent = m_parsedCalculation->category() == CalcPercent;
         value = m_parsedCalculation->doubleValue();
         m_parsedCalculation.release();
     } else {
@@ skipping 2119 matching lines @@
         }
         return nullptr;
     }
 
     if (!hasLengthOrPercentage)
         return nullptr;
 
     return list.release();
 }
 
-bool CSSPropertyParser::parseFontFeatureTag(CSSValueList* settings)
-{
-    // Feature tag name consists of 4-letter characters.
-    static const unsigned tagNameLength = 4;
-
-    CSSParserValue* value = m_valueList->current();
-    // Feature tag name comes first
-    if (value->unit() != CSSPrimitiveValue::UnitType::String)
-        return false;
-    if (value->string.length() != tagNameLength)
-        return false;
-    for (unsigned i = 0; i < tagNameLength; ++i) {
-        // Limits the range of characters to 0x20-0x7E, following the tag name rules defiend in the OpenType specification.
-        UChar character = value->string[i];
-        if (character < 0x20 || character > 0x7E)
-            return false;
-    }
-
-    AtomicString tag = value->string;
-    int tagValue = 1;
-    // Feature tag values could follow: <integer> | on | off
-    value = m_valueList->next();
-    if (value) {
-        if (value->unit() == CSSPrimitiveValue::UnitType::Number && value->isInt && value->fValue >= 0) {
-            tagValue = clampTo<int>(value->fValue);
-            if (tagValue < 0)
-                return false;
-            m_valueList->next();
-        } else if (value->id == CSSValueOn || value->id == CSSValueOff) {
-            tagValue = value->id == CSSValueOn;
-            m_valueList->next();
-        }
-    }
-    settings->append(CSSFontFeatureValue::create(tag, tagValue));
-    return true;
-}
-
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseFontFeatureSettings()
-{
-    RefPtrWillBeRawPtr<CSSValueList> settings = CSSValueList::createCommaSeparated();
-    while (true) {
-        if (!m_valueList->current() || !parseFontFeatureTag(settings.get()))
-            return nullptr;
-        if (!m_valueList->current())
-            break;
-        if (!consumeComma(m_valueList))
-            return nullptr;
-    }
-    return settings.release();
-}
-
-bool CSSPropertyParser::parseFontVariantLigatures(bool important)
-{
-    RefPtrWillBeRawPtr<CSSValueList> ligatureValues = CSSValueList::createSpaceSeparated();
-    bool sawCommonLigaturesValue = false;
-    bool sawDiscretionaryLigaturesValue = false;
-    bool sawHistoricalLigaturesValue = false;
-    bool sawContextualLigaturesValue = false;
-
-    for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
-        if (value->m_unit != CSSParserValue::Identifier)
-            return false;
-
-        switch (value->id) {
-        case CSSValueNoCommonLigatures:
-        case CSSValueCommonLigatures:
-            if (sawCommonLigaturesValue)
-                return false;
-            sawCommonLigaturesValue = true;
-            ligatureValues->append(cssValuePool().createIdentifierValue(value->id));
-            break;
-        case CSSValueNoDiscretionaryLigatures:
-        case CSSValueDiscretionaryLigatures:
-            if (sawDiscretionaryLigaturesValue)
-                return false;
-            sawDiscretionaryLigaturesValue = true;
-            ligatureValues->append(cssValuePool().createIdentifierValue(value->id));
-            break;
-        case CSSValueNoHistoricalLigatures:
-        case CSSValueHistoricalLigatures:
-            if (sawHistoricalLigaturesValue)
-                return false;
-            sawHistoricalLigaturesValue = true;
-            ligatureValues->append(cssValuePool().createIdentifierValue(value->id));
-            break;
-        case CSSValueNoContextual:
-        case CSSValueContextual:
-            if (sawContextualLigaturesValue)
-                return false;
-            sawContextualLigaturesValue = true;
-            ligatureValues->append(cssValuePool().createIdentifierValue(value->id));
-            break;
-        default:
-            return false;
-        }
-    }
-
-    if (!ligatureValues->length())
-        return false;
-
-    addProperty(CSSPropertyFontVariantLigatures, ligatureValues.release(), important);
-    return true;
-}
-
 bool CSSPropertyParser::parseCalculation(CSSParserValue* value, ValueRange range)
 {
     ASSERT(isCalculation(value));
 
     CSSParserTokenRange args = value->calcFunction->args;
 
     ASSERT(!m_parsedCalculation);
     m_parsedCalculation = CSSCalcValue::create(args, range);
 
     if (!m_parsedCalculation)
         return false;
 
     return true;
 }
 
-bool CSSPropertyParser::parseFontFaceDescriptor(CSSPropertyID propId)
-{
-    CSSParserValue* value = m_valueList->current();
-    ASSERT(value);
-    CSSValueID id = value->id;
-    RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
-
-    switch (propId) {
-    case CSSPropertyFontFamily:
-        // <family-name>
-        // TODO(rwlbuis): check there is only one family-name
-        parsedValue = parseFontFamily();
-        break;
-    case CSSPropertySrc: // This is a list of urls or local references.
-        parsedValue = parseFontFaceSrc();
-        break;
-    case CSSPropertyUnicodeRange:
-        parsedValue = parseFontFaceUnicodeRange();
-        break;
-    case CSSPropertyFontWeight: // normal | bold | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900
-        return parseFontWeight(false) && !m_valueList->next();
-    case CSSPropertyFontStretch:
-    case CSSPropertyFontStyle:
-        if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(propId, id))
-            return false;
-        addProperty(propId, cssValuePool().createIdentifierValue(id), false);
-        return true;
-    case CSSPropertyFontVariant: // normal | small-caps | inherit
-        return parseFontVariant(false);
-    case CSSPropertyWebkitFontFeatureSettings:
-        if (id == CSSValueNormal) {
-            parsedValue = cssValuePool().createIdentifierValue(CSSValueNormal);
-            m_valueList->next();
-        } else {
-            parsedValue = parseFontFeatureSettings();
-        }
-        break;
-    default:
-        break;
-    }
-
-    if (!parsedValue || m_valueList->current())
-        return false;
-
-    addProperty(propId, parsedValue.release(), false);
-    return true;
-}
-
 bool CSSPropertyParser::parseViewportProperty(CSSPropertyID propId, bool important)
 {
     ASSERT(RuntimeEnabledFeatures::cssViewportEnabled() || isUASheetBehavior(m_context.mode()));
 
     CSSParserValue* value = m_valueList->current();
     if (!value)
         return false;
 
     CSSValueID id = value->id;
     bool validPrimitive = false;
@@ skipping 640 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink