Changeset 206043 in webkit


Ignore:
Timestamp:
Sep 16, 2016 1:24:23 PM (8 years ago)
Author:
hyatt@apple.com
Message:

[CSS Parser] Get CSSPropertyParserHelpers.cpp compiling
​https://bugs.webkit.org/show_bug.cgi?id=162078

Reviewed by Dean Jackson.

Source/WebCore:

  • css/CSSCalculationValue.cpp:

(WebCore::hasDoubleValue):
(WebCore::checkDepthAndIndex):
(WebCore::CSSCalcExpressionNodeParser::parseCalc):
(WebCore::CSSCalcExpressionNodeParser::operatorValue):
(WebCore::CSSCalcExpressionNodeParser::parseValue):
(WebCore::CSSCalcExpressionNodeParser::parseValueTerm):
(WebCore::CSSCalcExpressionNodeParser::parseValueMultiplicativeExpression):
(WebCore::CSSCalcExpressionNodeParser::parseAdditiveValueExpression):
(WebCore::CSSCalcExpressionNodeParser::parseValueExpression):
(WebCore::checkDepthAndIndexDeprecated):
(WebCore::CSSCalcExpressionNodeParserDeprecated::parseValueTerm):
(WebCore::CSSCalcExpressionNodeParserDeprecated::parseValueMultiplicativeExpression):
(WebCore::CSSCalcExpressionNodeParserDeprecated::parseAdditiveValueExpression):
(WebCore::CSSCalcValue::create):

  • css/CSSCalculationValue.h:

(WebCore::CSSCalcValue::createCalculationValue):
(WebCore::CSSCalcValue::setPermittedValueRange):
Switch off the permitted calc value range enum, since we can just use the identical ValueRange enum.
Deprecate the CSSParserValueList-based parser by renaming it, and add a new parser that operates
on tokens.

  • css/CSSPrimitiveValue.cpp:

(WebCore::isValidCSSUnitTypeForDoubleConversion):
(WebCore::isStringType):
(WebCore::CSSPrimitiveValue::cleanup):
(WebCore::CSSPrimitiveValue::computeNonCalcLengthDouble):
(WebCore::CSSPrimitiveValue::formatNumberForCustomCSSText):
(WebCore::CSSPrimitiveValue::cloneForCSSOM):
(WebCore::CSSPrimitiveValue::equals):
(WebCore::CSSPrimitiveValue::buildParserValue):

  • css/CSSPrimitiveValue.h:

Add support for CSS_QUIRKY_EMS as a unit type. This will let us eliminate the extra m_isQuirkValue boolean
eventually.

  • css/parser/CSSParser.cpp:

(WebCore::CSSParser::validateCalculationUnit):
(WebCore::CSSParser::parseCalculation):

  • css/parser/CSSParser.h:

Switch to ValueRange.

  • css/parser/CSSParserIdioms.cpp:

(WebCore::completeURL):

  • css/parser/CSSParserIdioms.h:

Make the URL completion function from CSSParser.cpp available to all.

  • css/parser/CSSParserMode.h:

(WebCore::isUnitLessValueParsingEnabledForMode):
(WebCore::isUnitLessLengthParsingEnabledForMode): Deleted.
Rename this to value, since for now we're not supporting Blink's UserUnits. This means we need to support
unitless parsing for times and angles in addition to lengths, making the name of the function inappropriate.

  • css/parser/CSSParserToken.cpp:

(WebCore::cssPrimitiveValueUnitFromTrie):
Turn quirky ems support back on.

  • css/parser/CSSParserValues.cpp:

(WebCore::CSSParserValue::createCSSValue):
Support quirky ems.

  • css/parser/CSSPropertyParserHelpers.cpp:

(WebCore::CSSPropertyParserHelpers::CalcParser::consumeValue):
(WebCore::CSSPropertyParserHelpers::CalcParser::consumeNumber):
(WebCore::CSSPropertyParserHelpers::consumeInteger):
(WebCore::CSSPropertyParserHelpers::consumePositiveInteger):
(WebCore::CSSPropertyParserHelpers::consumeNumber):
(WebCore::CSSPropertyParserHelpers::shouldAcceptUnitlessValue):
(WebCore::CSSPropertyParserHelpers::consumeLength):
(WebCore::CSSPropertyParserHelpers::consumePercent):
(WebCore::CSSPropertyParserHelpers::canConsumeCalcValue):
(WebCore::CSSPropertyParserHelpers::consumeLengthOrPercent):
(WebCore::CSSPropertyParserHelpers::consumeAngle):
(WebCore::CSSPropertyParserHelpers::consumeTime):
(WebCore::CSSPropertyParserHelpers::consumeIdent):
(WebCore::CSSPropertyParserHelpers::consumeIdentRange):
(WebCore::CSSPropertyParserHelpers::consumeCustomIdent):
(WebCore::CSSPropertyParserHelpers::consumeString):
(WebCore::CSSPropertyParserHelpers::consumeUrl):
(WebCore::CSSPropertyParserHelpers::parseRGBParameters):
(WebCore::CSSPropertyParserHelpers::parseHSLParameters):
(WebCore::CSSPropertyParserHelpers::consumeColor):
(WebCore::CSSPropertyParserHelpers::consumePositionComponent):
(WebCore::CSSPropertyParserHelpers::positionFromOneValue):
(WebCore::CSSPropertyParserHelpers::positionFromTwoValues):
(WebCore::CSSPropertyParserHelpers::createPrimitiveValuePair):
(WebCore::CSSPropertyParserHelpers::positionFromThreeOrFourValues):
(WebCore::CSSPropertyParserHelpers::consumePosition):
(WebCore::CSSPropertyParserHelpers::consumeOneOrTwoValuedPosition):
(WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientPoint):
(WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientStopColor):
(WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientColorStop):
(WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradient):
(WebCore::CSSPropertyParserHelpers::consumeDeprecatedRadialGradient):
(WebCore::CSSPropertyParserHelpers::consumeRadialGradient):
(WebCore::CSSPropertyParserHelpers::consumeLinearGradient):
(WebCore::CSSPropertyParserHelpers::consumeImageOrNone):
(WebCore::CSSPropertyParserHelpers::consumeCrossFade):
(WebCore::CSSPropertyParserHelpers::consumeGeneratedImage):
(WebCore::CSSPropertyParserHelpers::consumeImageSet):
(WebCore::CSSPropertyParserHelpers::consumeImage):

  • css/parser/CSSPropertyParserHelpers.h:

(WebCore::CSSPropertyParserHelpers::isCSSWideKeyword):
Lots of changes here. The most important is switching over to RefPtrs and Refs where appropriate, with the
requisite WTFMoves. Unit types also have to be converted back to our values, and unitless parsing has
to work with consumeTime and consumeAngle.

  • platform/CalculationValue.cpp:

(WebCore::CalculationValue::create):

  • platform/CalculationValue.h:

(WebCore::CalculationValue::CalculationValue):
Use ValueRange.

  • platform/graphics/Color.cpp:

(WebCore::Color::parseHexColor):
(WebCore::Color::Color):

  • platform/graphics/Color.h:

Add a StringView-based parseHexColor function.

  • rendering/style/BasicShapes.cpp:

(WebCore::BasicShapeCenterCoordinate::updateComputedLength):
Use ValueRange

Tools:

  • TestWebKitAPI/Tests/WebCore/CalculationValue.cpp:

(TestWebKitAPI::createTestValue):
Convert to ValueRange.

Location:
trunk
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r206037 r206043  
     12016-09-16  Dave Hyatt  <hyatt@apple.com>
     2
     3        [CSS Parser] Get CSSPropertyParserHelpers.cpp compiling
     4        https://bugs.webkit.org/show_bug.cgi?id=162078
     5
     6        Reviewed by Dean Jackson.
     7
     8        * css/CSSCalculationValue.cpp:
     9        (WebCore::hasDoubleValue):
     10        (WebCore::checkDepthAndIndex):
     11        (WebCore::CSSCalcExpressionNodeParser::parseCalc):
     12        (WebCore::CSSCalcExpressionNodeParser::operatorValue):
     13        (WebCore::CSSCalcExpressionNodeParser::parseValue):
     14        (WebCore::CSSCalcExpressionNodeParser::parseValueTerm):
     15        (WebCore::CSSCalcExpressionNodeParser::parseValueMultiplicativeExpression):
     16        (WebCore::CSSCalcExpressionNodeParser::parseAdditiveValueExpression):
     17        (WebCore::CSSCalcExpressionNodeParser::parseValueExpression):
     18        (WebCore::checkDepthAndIndexDeprecated):
     19        (WebCore::CSSCalcExpressionNodeParserDeprecated::parseValueTerm):
     20        (WebCore::CSSCalcExpressionNodeParserDeprecated::parseValueMultiplicativeExpression):
     21        (WebCore::CSSCalcExpressionNodeParserDeprecated::parseAdditiveValueExpression):
     22        (WebCore::CSSCalcValue::create):
     23        * css/CSSCalculationValue.h:
     24        (WebCore::CSSCalcValue::createCalculationValue):
     25        (WebCore::CSSCalcValue::setPermittedValueRange):
     26        Switch off the permitted calc value range enum, since we can just use the identical ValueRange enum.
     27        Deprecate the CSSParserValueList-based parser by renaming it, and add a new parser that operates
     28        on tokens.
     29
     30        * css/CSSPrimitiveValue.cpp:
     31        (WebCore::isValidCSSUnitTypeForDoubleConversion):
     32        (WebCore::isStringType):
     33        (WebCore::CSSPrimitiveValue::cleanup):
     34        (WebCore::CSSPrimitiveValue::computeNonCalcLengthDouble):
     35        (WebCore::CSSPrimitiveValue::formatNumberForCustomCSSText):
     36        (WebCore::CSSPrimitiveValue::cloneForCSSOM):
     37        (WebCore::CSSPrimitiveValue::equals):
     38        (WebCore::CSSPrimitiveValue::buildParserValue):
     39        * css/CSSPrimitiveValue.h:
     40        Add support for CSS_QUIRKY_EMS as a unit type. This will let us eliminate the extra m_isQuirkValue boolean
     41        eventually.
     42
     43        * css/parser/CSSParser.cpp:
     44        (WebCore::CSSParser::validateCalculationUnit):
     45        (WebCore::CSSParser::parseCalculation):
     46        * css/parser/CSSParser.h:
     47        Switch to ValueRange.
     48
     49        * css/parser/CSSParserIdioms.cpp:
     50        (WebCore::completeURL):
     51        * css/parser/CSSParserIdioms.h:
     52        Make the URL completion function from CSSParser.cpp available to all.
     53
     54        * css/parser/CSSParserMode.h:
     55        (WebCore::isUnitLessValueParsingEnabledForMode):
     56        (WebCore::isUnitLessLengthParsingEnabledForMode): Deleted.
     57        Rename this to value, since for now we're not supporting Blink's UserUnits. This means we need to support
     58        unitless parsing for times and angles in addition to lengths, making the name of the function inappropriate.
     59
     60        * css/parser/CSSParserToken.cpp:
     61        (WebCore::cssPrimitiveValueUnitFromTrie):
     62        Turn quirky ems support back on.
     63
     64        * css/parser/CSSParserValues.cpp:
     65        (WebCore::CSSParserValue::createCSSValue):
     66        Support quirky ems.
     67
     68        * css/parser/CSSPropertyParserHelpers.cpp:
     69        (WebCore::CSSPropertyParserHelpers::CalcParser::consumeValue):
     70        (WebCore::CSSPropertyParserHelpers::CalcParser::consumeNumber):
     71        (WebCore::CSSPropertyParserHelpers::consumeInteger):
     72        (WebCore::CSSPropertyParserHelpers::consumePositiveInteger):
     73        (WebCore::CSSPropertyParserHelpers::consumeNumber):
     74        (WebCore::CSSPropertyParserHelpers::shouldAcceptUnitlessValue):
     75        (WebCore::CSSPropertyParserHelpers::consumeLength):
     76        (WebCore::CSSPropertyParserHelpers::consumePercent):
     77        (WebCore::CSSPropertyParserHelpers::canConsumeCalcValue):
     78        (WebCore::CSSPropertyParserHelpers::consumeLengthOrPercent):
     79        (WebCore::CSSPropertyParserHelpers::consumeAngle):
     80        (WebCore::CSSPropertyParserHelpers::consumeTime):
     81        (WebCore::CSSPropertyParserHelpers::consumeIdent):
     82        (WebCore::CSSPropertyParserHelpers::consumeIdentRange):
     83        (WebCore::CSSPropertyParserHelpers::consumeCustomIdent):
     84        (WebCore::CSSPropertyParserHelpers::consumeString):
     85        (WebCore::CSSPropertyParserHelpers::consumeUrl):
     86        (WebCore::CSSPropertyParserHelpers::parseRGBParameters):
     87        (WebCore::CSSPropertyParserHelpers::parseHSLParameters):
     88        (WebCore::CSSPropertyParserHelpers::consumeColor):
     89        (WebCore::CSSPropertyParserHelpers::consumePositionComponent):
     90        (WebCore::CSSPropertyParserHelpers::positionFromOneValue):
     91        (WebCore::CSSPropertyParserHelpers::positionFromTwoValues):
     92        (WebCore::CSSPropertyParserHelpers::createPrimitiveValuePair):
     93        (WebCore::CSSPropertyParserHelpers::positionFromThreeOrFourValues):
     94        (WebCore::CSSPropertyParserHelpers::consumePosition):
     95        (WebCore::CSSPropertyParserHelpers::consumeOneOrTwoValuedPosition):
     96        (WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientPoint):
     97        (WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientStopColor):
     98        (WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientColorStop):
     99        (WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradient):
     100        (WebCore::CSSPropertyParserHelpers::consumeDeprecatedRadialGradient):
     101        (WebCore::CSSPropertyParserHelpers::consumeRadialGradient):
     102        (WebCore::CSSPropertyParserHelpers::consumeLinearGradient):
     103        (WebCore::CSSPropertyParserHelpers::consumeImageOrNone):
     104        (WebCore::CSSPropertyParserHelpers::consumeCrossFade):
     105        (WebCore::CSSPropertyParserHelpers::consumeGeneratedImage):
     106        (WebCore::CSSPropertyParserHelpers::consumeImageSet):
     107        (WebCore::CSSPropertyParserHelpers::consumeImage):
     108        * css/parser/CSSPropertyParserHelpers.h:
     109        (WebCore::CSSPropertyParserHelpers::isCSSWideKeyword):
     110        Lots of changes here. The most important is switching over to RefPtrs and Refs where appropriate, with the
     111        requisite WTFMoves. Unit types also have to be converted back to our values, and unitless parsing has
     112        to work with consumeTime and consumeAngle.
     113
     114        * platform/CalculationValue.cpp:
     115        (WebCore::CalculationValue::create):
     116        * platform/CalculationValue.h:
     117        (WebCore::CalculationValue::CalculationValue):
     118        Use ValueRange.
     119
     120        * platform/graphics/Color.cpp:
     121        (WebCore::Color::parseHexColor):
     122        (WebCore::Color::Color):
     123        * platform/graphics/Color.h:
     124        Add a StringView-based parseHexColor function.
     125
     126        * rendering/style/BasicShapes.cpp:
     127        (WebCore::BasicShapeCenterCoordinate::updateComputedLength):
     128        Use ValueRange
     129
    11302016-09-16  Jer Noble  <jer.noble@apple.com>
    2131

  • trunk/Source/WebCore/css/CSSCalculationValue.cpp

    r205093 r206043  
    3434
    3535#include "CSSParser.h"
     36#include "CSSParserTokenRange.h"
    3637#include "CSSPrimitiveValueMappings.h"
    3738#include "StyleResolver.h"
    … …  
    143144    case CSSPrimitiveValue::CSS_SHAPE:
    144145    case CSSPrimitiveValue::CSS_QUAD:
     146    case CSSPrimitiveValue::CSS_QUIRKY_EMS:
    145147#if ENABLE(CSS_SCROLL_SNAP)
    146148    case CSSPrimitiveValue::CSS_LENGTH_REPEAT:
    … …  
    560562};
    561563
    562 static ParseState checkDepthAndIndex(int* depth, unsigned index, CSSParserValueList* tokens)
     564static ParseState checkDepthAndIndex(int* depth, CSSParserTokenRange tokens)
     565{
     566    (*depth)++;
     567    if (tokens.atEnd())
     568        return NoMoreTokens;
     569    if (*depth > maxExpressionDepth)
     570        return TooDeep;
     571    return OK;
     572}
     573
     574class CSSCalcExpressionNodeParser {
     575public:
     576    RefPtr<CSSCalcExpressionNode> parseCalc(CSSParserTokenRange tokens)
     577    {
     578        Value result;
     579        tokens.consumeWhitespace();
     580        bool ok = parseValueExpression(tokens, 0, &result);
     581        if (!ok || !tokens.atEnd())
     582            return nullptr;
     583        return result.value;
     584    }
     585   
     586private:
     587    struct Value {
     588        RefPtr<CSSCalcExpressionNode> value;
     589    };
     590   
     591    char operatorValue(const CSSParserToken& token)
     592    {
     593        if (token.type() == DelimiterToken)
     594            return token.delimiter();
     595        return 0;
     596    }
     597   
     598    bool parseValue(CSSParserTokenRange& tokens, Value* result)
     599    {
     600        CSSParserToken token = tokens.consumeIncludingWhitespace();
     601        if (!(token.type() == NumberToken || token.type() == PercentageToken || token.type() == DimensionToken))
     602            return false;
     603       
     604        CSSPrimitiveValue::UnitTypes type = token.unitType();
     605        if (unitCategory(type) == CalcOther)
     606            return false;
     607       
     608        result->value = CSSCalcPrimitiveValue::create(CSSPrimitiveValue::create(token.numericValue(), type), token.numericValueType() == IntegerValueType);
     609       
     610        return true;
     611    }
     612   
     613    bool parseValueTerm(CSSParserTokenRange& tokens, int depth, Value* result)
     614    {
     615        if (checkDepthAndIndex(&depth, tokens) != OK)
     616            return false;
     617       
     618        if (tokens.peek().type() == LeftParenthesisToken || tokens.peek().functionId() == CSSValueCalc) {
     619            CSSParserTokenRange innerRange = tokens.consumeBlock();
     620            tokens.consumeWhitespace();
     621            innerRange.consumeWhitespace();
     622            return parseValueExpression(innerRange, depth, result);
     623        }
     624       
     625        return parseValue(tokens, result);
     626    }
     627   
     628    bool parseValueMultiplicativeExpression(CSSParserTokenRange& tokens, int depth, Value* result)
     629    {
     630        if (checkDepthAndIndex(&depth, tokens) != OK)
     631            return false;
     632       
     633        if (!parseValueTerm(tokens, depth, result))
     634            return false;
     635       
     636        while (!tokens.atEnd()) {
     637            char operatorCharacter = operatorValue(tokens.peek());
     638            if (operatorCharacter != CalcMultiply && operatorCharacter != CalcDivide)
     639                break;
     640            tokens.consumeIncludingWhitespace();
     641           
     642            Value rhs;
     643            if (!parseValueTerm(tokens, depth, &rhs))
     644                return false;
     645           
     646            result->value = CSSCalcBinaryOperation::createSimplified(static_cast<CalcOperator>(operatorCharacter), result->value, rhs.value);
     647
     648            if (!result->value)
     649                return false;
     650        }
     651       
     652        return true;
     653    }
     654   
     655    bool parseAdditiveValueExpression(CSSParserTokenRange& tokens, int depth, Value* result)
     656    {
     657        if (checkDepthAndIndex(&depth, tokens) != OK)
     658            return false;
     659       
     660        if (!parseValueMultiplicativeExpression(tokens, depth, result))
     661            return false;
     662       
     663        while (!tokens.atEnd()) {
     664            char operatorCharacter = operatorValue(tokens.peek());
     665            if (operatorCharacter != CalcAdd && operatorCharacter != CalcSubtract)
     666                break;
     667            if ((&tokens.peek() - 1)->type() != WhitespaceToken)
     668                return false; // calc(1px+ 2px) is invalid
     669            tokens.consume();
     670            if (tokens.peek().type() != WhitespaceToken)
     671                return false; // calc(1px +2px) is invalid
     672            tokens.consumeIncludingWhitespace();
     673           
     674            Value rhs;
     675            if (!parseValueMultiplicativeExpression(tokens, depth, &rhs))
     676                return false;
     677           
     678            result->value = CSSCalcBinaryOperation::createSimplified(static_cast<CalcOperator>(operatorCharacter), result->value, rhs.value);
     679            if (!result->value)
     680                return false;
     681        }
     682       
     683        return true;
     684    }
     685   
     686    bool parseValueExpression(CSSParserTokenRange& tokens, int depth, Value* result)
     687    {
     688        return parseAdditiveValueExpression(tokens, depth, result);
     689    }
     690};
     691   
     692static ParseState checkDepthAndIndexDeprecated(int* depth, unsigned index, CSSParserValueList* tokens)
    563693{
    564694    (*depth)++;
    … …  
    570700}
    571701
    572 class CSSCalcExpressionNodeParser {
     702class CSSCalcExpressionNodeParserDeprecated {
    573703public:
    574704    RefPtr<CSSCalcExpressionNode> parseCalc(CSSParserValueList* tokens)
    … …  
    617747    bool parseValueTerm(CSSParserValueList* tokens, int depth, unsigned* index, Value* result)
    618748    {
    619         if (checkDepthAndIndex(&depth, *index, tokens) != OK)
     749        if (checkDepthAndIndexDeprecated(&depth, *index, tokens) != OK)
    620750            return false;
    621751
    … …  
    636766    bool parseValueMultiplicativeExpression(CSSParserValueList* tokens, int depth, unsigned* index, Value* result)
    637767    {
    638         if (checkDepthAndIndex(&depth, *index, tokens) != OK)
     768        if (checkDepthAndIndexDeprecated(&depth, *index, tokens) != OK)
    639769            return false;
    640770
    … …  
    663793    bool parseAdditiveValueExpression(CSSParserValueList* tokens, int depth, unsigned* index, Value* result)
    664794    {
    665         if (checkDepthAndIndex(&depth, *index, tokens) != OK)
     795        if (checkDepthAndIndexDeprecated(&depth, *index, tokens) != OK)
    666796            return false;
    667797
    … …  
    751881}
    752882
    753 RefPtr<CSSCalcValue> CSSCalcValue::create(CSSParserString name, CSSParserValueList& parserValueList, CalculationPermittedValueRange range)
    754 {
    755     CSSCalcExpressionNodeParser parser;
     883RefPtr<CSSCalcValue> CSSCalcValue::create(CSSParserString name, CSSParserValueList& parserValueList, ValueRange range)
     884{
     885    CSSCalcExpressionNodeParserDeprecated parser;
    756886    RefPtr<CSSCalcExpressionNode> expression;
    757887
    … …  
    759889        expression = parser.parseCalc(&parserValueList);
    760890
    761     return expression ? adoptRef(new CSSCalcValue(expression.releaseNonNull(), range != CalculationRangeAll)) : nullptr;
    762 }
    763 
     891    return expression ? adoptRef(new CSSCalcValue(expression.releaseNonNull(), range != ValueRangeAll)) : nullptr;
     892}
     893
     894RefPtr<CSSCalcValue> CSSCalcValue::create(const CSSParserTokenRange& tokens, ValueRange range)
     895{
     896    CSSCalcExpressionNodeParser parser;
     897    RefPtr<CSSCalcExpressionNode> expression = parser.parseCalc(tokens);
     898    return expression ? adoptRef(new CSSCalcValue(expression.releaseNonNull(), range != ValueRangeAll)) : nullptr;
     899
     900}
     901   
    764902RefPtr<CSSCalcValue> CSSCalcValue::create(const CalculationValue& value, const RenderStyle& style)
    765903{

  • trunk/Source/WebCore/css/CSSCalculationValue.h

    r205093 r206043  
    3636namespace WebCore {
    3737
     38class CSSParserTokenRange;
    3839class CSSParserValueList;
    3940class CSSToLengthConversionData;
    … …  
    8889class CSSCalcValue final : public CSSValue {
    8990public:
    90     static RefPtr<CSSCalcValue> create(CSSParserString name, CSSParserValueList& arguments, CalculationPermittedValueRange);
     91    // FIXME-NEWPARSER: Remove the CSSParserString create when old parser goes away.
     92    static RefPtr<CSSCalcValue> create(CSSParserString name, CSSParserValueList& arguments, ValueRange);
     93    static RefPtr<CSSCalcValue> create(const CSSParserTokenRange&, ValueRange);
     94   
    9195    static RefPtr<CSSCalcValue> create(const CalculationValue&, const RenderStyle&);
    9296
    … …  
    9599    double doubleValue() const;
    96100    bool isPositive() const { return m_expression->doubleValue() > 0; }
     101    bool isNegative() const { return m_expression->doubleValue() < 0; }
    97102    double computeLengthPx(const CSSToLengthConversionData&) const;
    98103    unsigned short primitiveType() const { return m_expression->primitiveType(); }
    99104
    100105    Ref<CalculationValue> createCalculationValue(const CSSToLengthConversionData&) const;
    101     void setPermittedValueRange(CalculationPermittedValueRange);
     106    void setPermittedValueRange(ValueRange);
    102107
    103108    String customCSSText() const;
    … …  
    123128{
    124129    return CalculationValue::create(m_expression->createCalcExpression(conversionData),
    125         m_shouldClampToNonNegative ? CalculationRangeNonNegative : CalculationRangeAll);
     130        m_shouldClampToNonNegative ? ValueRangeNonNegative : ValueRangeAll);
    126131}
    127132
    128 inline void CSSCalcValue::setPermittedValueRange(CalculationPermittedValueRange range)
     133inline void CSSCalcValue::setPermittedValueRange(ValueRange range)
    129134{
    130     m_shouldClampToNonNegative = range != CalculationRangeAll;
     135    m_shouldClampToNonNegative = range != ValueRangeAll;
    131136}
    132137

  • trunk/Source/WebCore/css/CSSPrimitiveValue.cpp

    r201782 r206043  
    7272    case CSSPrimitiveValue::CSS_DIMENSION:
    7373    case CSSPrimitiveValue::CSS_EMS:
     74    case CSSPrimitiveValue::CSS_QUIRKY_EMS:
    7475    case CSSPrimitiveValue::CSS_EXS:
    7576    case CSSPrimitiveValue::CSS_FR:
    … …  
    161162    case CSSPrimitiveValue::CSS_DPPX:
    162163    case CSSPrimitiveValue::CSS_EMS:
     164    case CSSPrimitiveValue::CSS_QUIRKY_EMS:
    163165    case CSSPrimitiveValue::CSS_EXS:
    164166    case CSSPrimitiveValue::CSS_FONT_FAMILY:
    … …  
    577579    case CSS_PERCENTAGE:
    578580    case CSS_EMS:
     581    case CSS_QUIRKY_EMS:
    579582    case CSS_EXS:
    580583    case CSS_REMS:
    … …  
    686689    switch (primitiveType) {
    687690    case CSS_EMS:
     691    case CSS_QUIRKY_EMS:
    688692        ASSERT(conversionData.style());
    689693        factor = conversionData.computingFontSize() ? conversionData.style()->fontDescription().specifiedSize() : conversionData.style()->fontDescription().computedSize();
    … …  
    10721076        return formatNumberValue("%");
    10731077    case CSS_EMS:
     1078    case CSS_QUIRKY_EMS:
    10741079        return formatNumberValue("em");
    10751080    case CSS_EXS:
    … …  
    11751180        RGBA32 rgbColor = m_value.rgbcolor;
    11761181        if (m_primitiveUnitType == CSS_PARSER_HEXCOLOR)
    1177             Color::parseHexColor(m_value.string, rgbColor);
     1182            Color::parseHexColor((String)m_value.string, rgbColor);
    11781183        return Color(rgbColor).cssText();
    11791184    }
    … …  
    13161321    case CSS_PERCENTAGE:
    13171322    case CSS_EMS:
     1323    case CSS_QUIRKY_EMS:
    13181324    case CSS_EXS:
    13191325    case CSS_REMS:
    … …  
    13801386    case CSS_PERCENTAGE:
    13811387    case CSS_EMS:
     1388    case CSS_QUIRKY_EMS:
    13821389    case CSS_EXS:
    13831390    case CSS_REMS:
    … …  
    14651472    case CSS_PERCENTAGE:
    14661473    case CSS_EMS:
     1474    case CSS_QUIRKY_EMS:
    14671475    case CSS_EXS:
    14681476    case CSS_REMS:

  • trunk/Source/WebCore/css/CSSPrimitiveValue.h

    r205093 r206043  
    157157       
    158158        // More internal parse stuff for CSS variables
    159         CSS_PARSER_WHITESPACE = 119
     159        CSS_PARSER_WHITESPACE = 119,
     160       
     161        // This value is used to handle quirky margins in reflow roots (body, td, and th) like WinIE.
     162        // The basic idea is that a stylesheet can use the value __qem (for quirky em) instead of em.
     163        // When the quirky value is used, if you're in quirks mode, the margin will collapse away
     164        // inside a table cell. This quirk is specified in the HTML spec but our impl is different.
     165        CSS_QUIRKY_EMS = 120
    160166    };
    161167
    … …  
    190196            || primitiveUnitType == CSS_EXS
    191197            || primitiveUnitType == CSS_REMS
    192             || primitiveUnitType == CSS_CHS;
     198            || primitiveUnitType == CSS_CHS
     199            || primitiveUnitType == CSS_QUIRKY_EMS;
    193200    }
    194201    bool isFontRelativeLength() const { return isFontRelativeLength(m_primitiveUnitType); }
     202   
     203    bool isQuirkyEms() const { return primitiveType() == UnitTypes::CSS_QUIRKY_EMS; }
    195204
    196205    static bool isViewportPercentageLength(unsigned short type) { return type >= CSS_VW && type <= CSS_VMAX; }
    … …  
    199208    static bool isLength(unsigned short type)
    200209    {
    201         return (type >= CSS_EMS && type <= CSS_PC) || type == CSS_REMS || type == CSS_CHS || isViewportPercentageLength(type);
     210        return (type >= CSS_EMS && type <= CSS_PC) || type == CSS_REMS || type == CSS_CHS || isViewportPercentageLength(type) || type == CSS_QUIRKY_EMS;
    202211    }
    203212
    … …  
    370379    String customCSSText() const;
    371380
    372     bool isQuirkValue() const { return m_isQuirkValue; }
     381    // FIXME-NEWPARSER: Can ditch the boolean and just use the unit type once old parser is gone.
     382    bool isQuirkValue() const { return m_isQuirkValue || primitiveType() == CSS_QUIRKY_EMS; }
    373383
    374384    void addSubresourceStyleURLs(ListHashSet<URL>&, const StyleSheetContents*) const;

  • trunk/Source/WebCore/css/StyleBuilderConverter.h

    r205977 r206043  
    319319    auto rhs = std::make_unique<CalcExpressionLength>(length);
    320320    auto op = std::make_unique<CalcExpressionBinaryOperation>(WTFMove(lhs), WTFMove(rhs), CalcSubtract);
    321     return Length(CalculationValue::create(WTFMove(op), CalculationRangeAll));
     321    return Length(CalculationValue::create(WTFMove(op), ValueRangeAll));
    322322}
    323323

  • trunk/Source/WebCore/css/parser/CSSParser.cpp

    r205984 r206043  
    16211621        // The calculation value was already parsed so we reuse it. However, we may need to update its range.
    16221622        calculation = valueWithCalculation.calculation();
    1623         calculation->setPermittedValueRange(mustBeNonNegative ? CalculationRangeNonNegative : CalculationRangeAll);
     1623        calculation->setPermittedValueRange(mustBeNonNegative ? ValueRangeNonNegative : ValueRangeAll);
    16241624    } else {
    1625         valueWithCalculation.setCalculation(parseCalculation(valueWithCalculation, mustBeNonNegative ? CalculationRangeNonNegative : CalculationRangeAll));
     1625        valueWithCalculation.setCalculation(parseCalculation(valueWithCalculation, mustBeNonNegative ? ValueRangeNonNegative : ValueRangeAll));
    16261626        calculation = valueWithCalculation.calculation();
    16271627        if (!calculation)
    … …  
    1104311043}
    1104411044
    11045 RefPtr<CSSCalcValue> CSSParser::parseCalculation(CSSParserValue& value, CalculationPermittedValueRange range)
     11045RefPtr<CSSCalcValue> CSSParser::parseCalculation(CSSParserValue& value, ValueRange range)
    1104611046{
    1104711047    ASSERT(isCalculation(value));

  • trunk/Source/WebCore/css/parser/CSSParser.h

    r205924 r206043  
    360360
    361361    bool parseLineBoxContain(bool important);
    362     RefPtr<CSSCalcValue> parseCalculation(CSSParserValue&, CalculationPermittedValueRange);
     362    RefPtr<CSSCalcValue> parseCalculation(CSSParserValue&, ValueRange);
    363363
    364364    bool parseFontFeatureTag(CSSValueList&);

  • trunk/Source/WebCore/css/parser/CSSParserIdioms.cpp

    r206007 r206043  
    3131#include "CSSParserIdioms.h"
    3232#include "CSSValueKeywords.h"
     33#include "TextEncoding.h"
    3334
    3435namespace WebCore {
    … …  
    6263}
    6364
     65URL completeURL(const CSSParserContext& context, const String& url)
     66{
     67    if (url.isNull())
     68        return URL();
     69    if (context.charset.isEmpty())
     70        return URL(context.baseURL, url);
     71    return URL(context.baseURL, url, context.charset);
     72}
     73
    6474} // namespace WebCore

  • trunk/Source/WebCore/css/parser/CSSParserIdioms.h

    r206007 r206043  
    3939namespace WebCore {
    4040
     41class URL;
     42   
    4143// Space characters as defined by the CSS specification.
    4244// http://www.w3.org/TR/css3-syntax/#whitespace
    … …  
    6365
    6466bool isValueAllowedInMode(unsigned short, CSSParserMode);
    65    
     67
     68URL completeURL(const CSSParserContext&, const String& url);
     69
    6670}
    6771

  • trunk/Source/WebCore/css/parser/CSSParserMode.h

    r205984 r206043  
    6363}
    6464
    65 inline bool isUnitLessLengthParsingEnabledForMode(CSSParserMode mode)
     65inline bool isUnitLessValueParsingEnabledForMode(CSSParserMode mode)
    6666{
    6767    return mode == HTMLAttributeMode || mode == SVGAttributeMode;

  • trunk/Source/WebCore/css/parser/CSSParserToken.cpp

    r205103 r206043  
    190190        case '_':
    191191            if (toASCIILower(data[1]) == '_' && toASCIILower(data[2]) == 'q' && toASCIILower(data[3]) == 'e' && toASCIILower(data[4]) == 'm')
    192                 return CSSPrimitiveValue::UnitTypes::CSS_EMS; // FIXME-NEWPARSER: Need quirky ems.
     192                return CSSPrimitiveValue::UnitTypes::CSS_QUIRKY_EMS;
    193193            break;
    194194        }

  • trunk/Source/WebCore/css/parser/CSSParserValues.cpp

    r205790 r206043  
    127127    case CSSPrimitiveValue::CSS_PERCENTAGE:
    128128    case CSSPrimitiveValue::CSS_EMS:
     129    case CSSPrimitiveValue::CSS_QUIRKY_EMS:
    129130    case CSSPrimitiveValue::CSS_EXS:
    130131    case CSSPrimitiveValue::CSS_PX:

  • trunk/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp

    r205103 r206043  
    3232
    3333#include "CSSCalculationValue.h"
    34 // FIXME-NEWPARSER: #include "CSSColorValue.h"
    3534#include "CSSCrossfadeValue.h"
    3635#include "CSSGradientValue.h"
    3736#include "CSSImageSetValue.h"
    3837#include "CSSImageValue.h"
    39 // FIXME-NEWPARSER: #include "CSSPaintValue.h"
    40 // FIXME_NEWPARSER: #include "CSSStringValue.h"
    41 // FIXME-NEWPARSER: #include "CSSURIValue.h"
    42 // FIXME_NEWPARSER: #include "CSSValuePair.h"
     38#include "CSSParserIdioms.h"
     39#include "CSSValuePool.h"
     40#include "Pair.h"
     41#include "StyleColor.h"
    4342
    4443namespace WebCore {
    4544
    46 /* FIXME-NEWPARSER: Disable for now.
    47  
    4845namespace CSSPropertyParserHelpers {
    4946
    … …  
    8986
    9087    const CSSCalcValue* value() const { return m_calcValue.get(); }
    91     CSSPrimitiveValue* consumeValue()
     88    RefPtr<CSSPrimitiveValue> consumeValue()
    9289    {
    9390        if (!m_calcValue)
    … …  
    9693        return CSSPrimitiveValue::create(m_calcValue.release());
    9794    }
    98     CSSPrimitiveValue* consumeNumber()
     95    RefPtr<CSSPrimitiveValue> consumeNumber()
    9996    {
    10097        if (!m_calcValue)
    10198            return nullptr;
    10299        m_sourceRange = m_range;
    103         CSSPrimitiveValue::UnitType unitType = m_calcValue->isInt() ? CSSPrimitiveValue::UnitType::Integer : CSSPrimitiveValue::UnitType::Number;
     100        CSSPrimitiveValue::UnitTypes unitType = m_calcValue->isInt() ? CSSPrimitiveValue::UnitTypes::CSS_PARSER_INTEGER : CSSPrimitiveValue::UnitTypes::CSS_NUMBER;
    104101        return CSSPrimitiveValue::create(m_calcValue->doubleValue(), unitType);
    105102    }
    … …  
    117114    CSSParserTokenRange& m_sourceRange;
    118115    CSSParserTokenRange m_range;
    119     Member<CSSCalcValue> m_calcValue;
     116    RefPtr<CSSCalcValue> m_calcValue;
    120117};
    121118
    122 CSSPrimitiveValue* consumeInteger(CSSParserTokenRange& range, double minimumValue)
     119RefPtr<CSSPrimitiveValue> consumeInteger(CSSParserTokenRange& range, double minimumValue)
    123120{
    124121    const CSSParserToken& token = range.peek();
    … …  
    126123        if (token.numericValueType() == NumberValueType || token.numericValue() < minimumValue)
    127124            return nullptr;
    128         return CSSPrimitiveValue::create(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::Integer);
     125        return CSSPrimitiveValue::create(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitTypes::CSS_PARSER_INTEGER);
    129126    }
    130127    CalcParser calcParser(range);
    … …  
    140137}
    141138
    142 CSSPrimitiveValue* consumePositiveInteger(CSSParserTokenRange& range)
     139RefPtr<CSSPrimitiveValue> consumePositiveInteger(CSSParserTokenRange& range)
    143140{
    144141    return consumeInteger(range, 1);
    … …  
    156153
    157154// FIXME: Work out if this can just call consumeNumberRaw
    158 CSSPrimitiveValue* consumeNumber(CSSParserTokenRange& range, ValueRange valueRange)
     155RefPtr<CSSPrimitiveValue> consumeNumber(CSSParserTokenRange& range, ValueRange valueRange)
    159156{
    160157    const CSSParserToken& token = range.peek();
    … …  
    175172}
    176173
    177 inline bool shouldAcceptUnitlessLength(double value, CSSParserMode cssParserMode, UnitlessQuirk unitless)
     174inline bool shouldAcceptUnitlessValue(double value, CSSParserMode cssParserMode, UnitlessQuirk unitless)
    178175{
    179176    // FIXME: Presentational HTML attributes shouldn't use the CSS parser for lengths
    180177    return value == 0
    181         || isUnitLessLengthParsingEnabledForMode(cssParserMode)
     178        || isUnitLessValueParsingEnabledForMode(cssParserMode)
    182179        || (cssParserMode == HTMLQuirksMode && unitless == UnitlessQuirk::Allow);
    183180}
    184181
    185 CSSPrimitiveValue* consumeLength(CSSParserTokenRange& range, CSSParserMode cssParserMode, ValueRange valueRange, UnitlessQuirk unitless)
     182RefPtr<CSSPrimitiveValue> consumeLength(CSSParserTokenRange& range, CSSParserMode cssParserMode, ValueRange valueRange, UnitlessQuirk unitless)
    186183{
    187184    const CSSParserToken& token = range.peek();
    188185    if (token.type() == DimensionToken) {
    189186        switch (token.unitType()) {
    190         case CSSPrimitiveValue::UnitType::QuirkyEms:
     187        case CSSPrimitiveValue::UnitTypes::CSS_QUIRKY_EMS:
    191188            if (cssParserMode != UASheetMode)
    192189                return nullptr;
    193190            FALLTHROUGH;
    194         case CSSPrimitiveValue::UnitType::Ems:
    195         case CSSPrimitiveValue::UnitType::Rems:
    196         case CSSPrimitiveValue::UnitType::Chs:
    197         case CSSPrimitiveValue::UnitType::Exs:
    198         case CSSPrimitiveValue::UnitType::Pixels:
    199         case CSSPrimitiveValue::UnitType::Centimeters:
    200         case CSSPrimitiveValue::UnitType::Millimeters:
    201         case CSSPrimitiveValue::UnitType::Inches:
    202         case CSSPrimitiveValue::UnitType::Points:
    203         case CSSPrimitiveValue::UnitType::Picas:
    204         case CSSPrimitiveValue::UnitType::UserUnits:
    205         case CSSPrimitiveValue::UnitType::ViewportWidth:
    206         case CSSPrimitiveValue::UnitType::ViewportHeight:
    207         case CSSPrimitiveValue::UnitType::ViewportMin:
    208         case CSSPrimitiveValue::UnitType::ViewportMax:
     191        case CSSPrimitiveValue::UnitTypes::CSS_EMS:
     192        case CSSPrimitiveValue::UnitTypes::CSS_REMS:
     193        case CSSPrimitiveValue::UnitTypes::CSS_CHS:
     194        case CSSPrimitiveValue::UnitTypes::CSS_EXS:
     195        case CSSPrimitiveValue::UnitTypes::CSS_PX:
     196        case CSSPrimitiveValue::UnitTypes::CSS_CM:
     197        case CSSPrimitiveValue::UnitTypes::CSS_MM:
     198        case CSSPrimitiveValue::UnitTypes::CSS_IN:
     199        case CSSPrimitiveValue::UnitTypes::CSS_PT:
     200        case CSSPrimitiveValue::UnitTypes::CSS_PC:
     201        case CSSPrimitiveValue::UnitTypes::CSS_VW:
     202        case CSSPrimitiveValue::UnitTypes::CSS_VH:
     203        case CSSPrimitiveValue::UnitTypes::CSS_VMIN:
     204        case CSSPrimitiveValue::UnitTypes::CSS_VMAX:
    209205            break;
    210206        default:
    … …  
    216212    }
    217213    if (token.type() == NumberToken) {
    218         if (!shouldAcceptUnitlessLength(token.numericValue(), cssParserMode, unitless)
     214        if (!shouldAcceptUnitlessValue(token.numericValue(), cssParserMode, unitless)
    219215            || (valueRange == ValueRangeNonNegative && token.numericValue() < 0))
    220216            return nullptr;
    221         CSSPrimitiveValue::UnitType unitType = CSSPrimitiveValue::UnitType::Pixels;
    222         if (cssParserMode == SVGAttributeMode)
    223             unitType = CSSPrimitiveValue::UnitType::UserUnits;
     217        CSSPrimitiveValue::UnitTypes unitType = CSSPrimitiveValue::UnitTypes::CSS_PX;
    224218        return CSSPrimitiveValue::create(range.consumeIncludingWhitespace().numericValue(), unitType);
    225219    }
    … …  
    232226}
    233227
    234 CSSPrimitiveValue* consumePercent(CSSParserTokenRange& range, ValueRange valueRange)
     228RefPtr<CSSPrimitiveValue> consumePercent(CSSParserTokenRange& range, ValueRange valueRange)
    235229{
    236230    const CSSParserToken& token = range.peek();
    … …  
    238232        if (valueRange == ValueRangeNonNegative && token.numericValue() < 0)
    239233            return nullptr;
    240         return CSSPrimitiveValue::create(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::Percentage);
     234        return CSSPrimitiveValue::create(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitTypes::CSS_PERCENTAGE);
    241235    }
    242236    CalcParser calcParser(range, valueRange);
    … …  
    248242}
    249243
    250 bool canConsumeCalcValue(CalculationCategory category, CSSParserMode cssParserMode)
     244static bool canConsumeCalcValue(CalculationCategory category, CSSParserMode cssParserMode)
    251245{
    252246    if (category == CalcLength || category == CalcPercent || category == CalcPercentLength)
    … …  
    256250        return false;
    257251
    258     if (category == CalcNumber || category == CalcPercentNumber || category == CalcLengthNumber || category == CalcPercentLengthNumber)
     252    if (category == CalcNumber || category == CalcPercentNumber)
    259253        return true;
    260254
    … …  
    262256}
    263257
    264 CSSPrimitiveValue* consumeLengthOrPercent(CSSParserTokenRange& range, CSSParserMode cssParserMode, ValueRange valueRange, UnitlessQuirk unitless)
     258RefPtr<CSSPrimitiveValue> consumeLengthOrPercent(CSSParserTokenRange& range, CSSParserMode cssParserMode, ValueRange valueRange, UnitlessQuirk unitless)
    265259{
    266260    const CSSParserToken& token = range.peek();
    … …  
    277271}
    278272
    279 CSSPrimitiveValue* consumeAngle(CSSParserTokenRange& range)
     273RefPtr<CSSPrimitiveValue> consumeAngle(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
    280274{
    281275    const CSSParserToken& token = range.peek();
    282276    if (token.type() == DimensionToken) {
    283277        switch (token.unitType()) {
    284         case CSSPrimitiveValue::UnitType::Degrees:
    285         case CSSPrimitiveValue::UnitType::Radians:
    286         case CSSPrimitiveValue::UnitType::Gradians:
    287         case CSSPrimitiveValue::UnitType::Turns:
     278        case CSSPrimitiveValue::UnitTypes::CSS_DEG:
     279        case CSSPrimitiveValue::UnitTypes::CSS_RAD:
     280        case CSSPrimitiveValue::UnitTypes::CSS_GRAD:
     281        case CSSPrimitiveValue::UnitTypes::CSS_TURN:
    288282            return CSSPrimitiveValue::create(range.consumeIncludingWhitespace().numericValue(), token.unitType());
    289283        default:
    … …  
    291285        }
    292286    }
    293     if (token.type() == NumberToken && token.numericValue() == 0) {
     287    if (token.type() == NumberToken && shouldAcceptUnitlessValue(token.numericValue(), cssParserMode, unitless)) {
    294288        range.consumeIncludingWhitespace();
    295         return CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::Degrees);
    296     }
     289        return CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitTypes::CSS_DEG);
     290    }
     291
    297292    CalcParser calcParser(range, ValueRangeAll);
    298293    if (const CSSCalcValue* calculation = calcParser.value()) {
    … …  
    303298}
    304299
    305 CSSPrimitiveValue* consumeTime(CSSParserTokenRange& range, ValueRange valueRange)
     300RefPtr<CSSPrimitiveValue> consumeTime(CSSParserTokenRange& range, CSSParserMode cssParserMode, ValueRange valueRange, UnitlessQuirk unitless)
    306301{
    307302    const CSSParserToken& token = range.peek();
    308     if (token.type() == DimensionToken) {
     303    CSSPrimitiveValue::UnitTypes unit = token.unitType();
     304    bool acceptUnitless = token.type() == NumberToken && shouldAcceptUnitlessValue(token.numericValue(), cssParserMode, unitless);
     305    if (acceptUnitless)
     306        unit = CSSPrimitiveValue::UnitTypes::CSS_MS;
     307    if (token.type() == DimensionToken || acceptUnitless) {
    309308        if (valueRange == ValueRangeNonNegative && token.numericValue() < 0)
    310309            return nullptr;
    311         CSSPrimitiveValue::UnitType unit = token.unitType();
    312         if (unit == CSSPrimitiveValue::UnitType::Milliseconds || unit == CSSPrimitiveValue::UnitType::Seconds)
     310        if (unit == CSSPrimitiveValue::UnitTypes::CSS_MS || unit == CSSPrimitiveValue::UnitTypes::CSS_S)
    313311            return CSSPrimitiveValue::create(range.consumeIncludingWhitespace().numericValue(), token.unitType());
    314312        return nullptr;
    … …  
    322320}
    323321
    324 CSSPrimitiveValue* consumeIdent(CSSParserTokenRange& range)
     322RefPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange& range)
    325323{
    326324    if (range.peek().type() != IdentToken)
    … …  
    329327}
    330328
    331 CSSPrimitiveValue* consumeIdentRange(CSSParserTokenRange& range, CSSValueID lower, CSSValueID upper)
     329RefPtr<CSSPrimitiveValue> consumeIdentRange(CSSParserTokenRange& range, CSSValueID lower, CSSValueID upper)
    332330{
    333331    if (range.peek().id() < lower || range.peek().id() > upper)
    … …  
    336334}
    337335
    338 CSSCustomIdentValue* consumeCustomIdent(CSSParserTokenRange& range)
     336RefPtr<CSSCustomIdentValue> consumeCustomIdent(CSSParserTokenRange& range)
    339337{
    340338    if (range.peek().type() != IdentToken || isCSSWideKeyword(range.peek().id()))
    … …  
    343341}
    344342
    345 CSSStringValue* consumeString(CSSParserTokenRange& range)
     343RefPtr<CSSPrimitiveValue> consumeString(CSSParserTokenRange& range)
    346344{
    347345    if (range.peek().type() != StringToken)
    348346        return nullptr;
    349     return CSSStringValue::create(range.consumeIncludingWhitespace().value().toString());
     347    return CSSPrimitiveValue::create(range.consumeIncludingWhitespace().value().toString(), CSSPrimitiveValue::UnitTypes::CSS_STRING);
    350348}
    351349
    … …  
    372370}
    373371
    374 CSSURIValue* consumeUrl(CSSParserTokenRange& range)
     372RefPtr<CSSPrimitiveValue> consumeUrl(CSSParserTokenRange& range)
    375373{
    376374    StringView url = consumeUrlAsStringView(range);
    377375    if (url.isNull())
    378376        return nullptr;
    379     return CSSURIValue::create(url.toString());
     377    return CSSPrimitiveValue::create(url.toString(), CSSPrimitiveValue::UnitTypes::CSS_URI);
    380378}
    381379
    … …  
    393391    ASSERT(range.peek().functionId() == CSSValueRgb || range.peek().functionId() == CSSValueRgba);
    394392    CSSParserTokenRange args = consumeFunction(range);
    395     CSSPrimitiveValue* colorParameter = consumeInteger(args);
     393    RefPtr<CSSPrimitiveValue> colorParameter = consumeInteger(args);
    396394    if (!colorParameter)
    397395        colorParameter = consumePercent(args, ValueRangeAll);
    … …  
    429427    ASSERT(range.peek().functionId() == CSSValueHsl || range.peek().functionId() == CSSValueHsla);
    430428    CSSParserTokenRange args = consumeFunction(range);
    431     CSSPrimitiveValue* hslValue = consumeNumber(args, ValueRangeAll);
     429    RefPtr<CSSPrimitiveValue> hslValue = consumeNumber(args, ValueRangeAll);
    432430    if (!hslValue)
    433431        return false;
    … …  
    501499}
    502500
    503 CSSValue* consumeColor(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool acceptQuirkyColors)
     501RefPtr<CSSPrimitiveValue> consumeColor(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool acceptQuirkyColors)
    504502{
    505503    CSSValueID id = range.peek().id();
    … …  
    512510    if (!parseHexColor(range, color, acceptQuirkyColors) && !parseColorFunction(range, color))
    513511        return nullptr;
    514     return CSSColorValue::create(color);
    515 }
    516 
    517 static CSSPrimitiveValue* consumePositionComponent(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
     512    return CSSPrimitiveValue::createColor(color);
     513}
     514
     515static RefPtr<CSSPrimitiveValue> consumePositionComponent(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
    518516{
    519517    if (range.peek().type() == IdentToken)
    … …  
    532530}
    533531
    534 static void positionFromOneValue(CSSPrimitiveValue* value, CSSValue*& resultX, CSSValue*& resultY)
    535 {
    536     bool valueAppliesToYAxisOnly = isVerticalPositionKeywordOnly(*value);
    537     resultX = value;
     532static void positionFromOneValue(CSSPrimitiveValue& value, RefPtr<CSSPrimitiveValue>& resultX, RefPtr<CSSPrimitiveValue>& resultY)
     533{
     534    bool valueAppliesToYAxisOnly = isVerticalPositionKeywordOnly(value);
     535    resultX = &value;
    538536    resultY = CSSPrimitiveValue::createIdentifier(CSSValueCenter);
    539537    if (valueAppliesToYAxisOnly)
    … …  
    541539}
    542540
    543 static bool positionFromTwoValues(CSSPrimitiveValue* value1, CSSPrimitiveValue* value2,
    544     CSSValue*& resultX, CSSValue*& resultY)
    545 {
    546     bool mustOrderAsXY = isHorizontalPositionKeywordOnly(*value1) || isVerticalPositionKeywordOnly(*value2)
    547         || !value1->isValueID() || !value2->isValueID();
    548     bool mustOrderAsYX = isVerticalPositionKeywordOnly(*value1) || isHorizontalPositionKeywordOnly(*value2);
     541static bool positionFromTwoValues(CSSPrimitiveValue& value1, CSSPrimitiveValue& value2,
     542    RefPtr<CSSPrimitiveValue>& resultX, RefPtr<CSSPrimitiveValue>& resultY)
     543{
     544    bool mustOrderAsXY = isHorizontalPositionKeywordOnly(value1) || isVerticalPositionKeywordOnly(value2)
     545        || !value1.isValueID() || !value2.isValueID();
     546    bool mustOrderAsYX = isVerticalPositionKeywordOnly(value1) || isHorizontalPositionKeywordOnly(value2);
    549547    if (mustOrderAsXY && mustOrderAsYX)
    550548        return false;
    551     resultX = value1;
    552     resultY = value2;
     549    resultX = &value1;
     550    resultY = &value2;
    553551    if (mustOrderAsYX)
    554552        std::swap(resultX, resultY);
    … …  
    556554}
    557555
    558 static bool positionFromThreeOrFourValues(CSSPrimitiveValue** values, CSSValue*& resultX, CSSValue*& resultY)
     556   
     557template<typename... Args>
     558static Ref<CSSPrimitiveValue> createPrimitiveValuePair(Args&&... args)
     559{
     560    return CSSValuePool::singleton().createValue(Pair::create(std::forward<Args>(args)...));
     561}
     562
     563static bool positionFromThreeOrFourValues(CSSPrimitiveValue** values, RefPtr<CSSPrimitiveValue>& resultX, RefPtr<CSSPrimitiveValue>& resultY)
    559564{
    560565    CSSPrimitiveValue* center = nullptr;
    … …  
    572577        }
    573578
    574         CSSValue* result = nullptr;
    575         if (values[i + 1] && !values[i + 1]->isValueID()) {
    576             result = CSSValuePair::create(currentValue, values[++i], CSSValuePair::KeepIdenticalValues);
    577         } else {
     579        RefPtr<CSSPrimitiveValue> result;
     580        if (values[i + 1] && !values[i + 1]->isValueID())
     581            result = createPrimitiveValuePair(currentValue, values[++i]);
     582        else
    578583            result = currentValue;
    579         }
    580584
    581585        if (id == CSSValueLeft || id == CSSValueRight) {
    … …  
    607611// FIXME: This may consume from the range upon failure. The background
    608612// shorthand works around it, but we should just fix it here.
    609 bool consumePosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless, CSSValue*& resultX, CSSValue*& resultY)
    610 {
    611     CSSPrimitiveValue* value1 = consumePositionComponent(range, cssParserMode, unitless);
     613bool consumePosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless, RefPtr<CSSPrimitiveValue>& resultX, RefPtr<CSSPrimitiveValue>& resultY)
     614{
     615    RefPtr<CSSPrimitiveValue> value1 = consumePositionComponent(range, cssParserMode, unitless);
    612616    if (!value1)
    613617        return false;
    614618
    615     CSSPrimitiveValue* value2 = consumePositionComponent(range, cssParserMode, unitless);
     619    RefPtr<CSSPrimitiveValue> value2 = consumePositionComponent(range, cssParserMode, unitless);
    616620    if (!value2) {
    617         positionFromOneValue(value1, resultX, resultY);
     621        positionFromOneValue(*value1, resultX, resultY);
    618622        return true;
    619623    }
    620624
    621     CSSPrimitiveValue* value3 = consumePositionComponent(range, cssParserMode, unitless);
     625    RefPtr<CSSPrimitiveValue> value3 = consumePositionComponent(range, cssParserMode, unitless);
    622626    if (!value3)
    623         return positionFromTwoValues(value1, value2, resultX, resultY);
    624 
    625     CSSPrimitiveValue* value4 = consumePositionComponent(range, cssParserMode, unitless);
     627        return positionFromTwoValues(*value1, *value2, resultX, resultY);
     628
     629    RefPtr<CSSPrimitiveValue> value4 = consumePositionComponent(range, cssParserMode, unitless);
    626630    CSSPrimitiveValue* values[5];
    627     values[0] = value1;
    628     values[1] = value2;
    629     values[2] = value3;
    630     values[3] = value4;
     631    values[0] = value1.get();
     632    values[1] = value2.get();
     633    values[2] = value3.get();
     634    values[3] = value4.get();
    631635    values[4] = nullptr;
    632636    return positionFromThreeOrFourValues(values, resultX, resultY);
    633637}
    634638
    635 CSSValuePair* consumePosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
    636 {
    637     CSSValue* resultX = nullptr;
    638     CSSValue* resultY = nullptr;
     639RefPtr<CSSPrimitiveValue> consumePosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
     640{
     641    RefPtr<CSSPrimitiveValue> resultX;
     642    RefPtr<CSSPrimitiveValue> resultY;
    639643    if (consumePosition(range, cssParserMode, unitless, resultX, resultY))
    640         return CSSValuePair::create(resultX, resultY, CSSValuePair::KeepIdenticalValues);
     644        return createPrimitiveValuePair(resultX.releaseNonNull(), resultY.releaseNonNull());
    641645    return nullptr;
    642646}
    643647
    644 bool consumeOneOrTwoValuedPosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless, CSSValue*& resultX, CSSValue*& resultY)
    645 {
    646     CSSPrimitiveValue* value1 = consumePositionComponent(range, cssParserMode, unitless);
     648bool consumeOneOrTwoValuedPosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless, RefPtr<CSSPrimitiveValue>& resultX, RefPtr<CSSPrimitiveValue>& resultY)
     649{
     650    RefPtr<CSSPrimitiveValue> value1 = consumePositionComponent(range, cssParserMode, unitless);
    647651    if (!value1)
    648652        return false;
    649     CSSPrimitiveValue* value2 = consumePositionComponent(range, cssParserMode, unitless);
     653    RefPtr<CSSPrimitiveValue> value2 = consumePositionComponent(range, cssParserMode, unitless);
    650654    if (!value2) {
    651         positionFromOneValue(value1, resultX, resultY);
     655        positionFromOneValue(*value1, resultX, resultY);
    652656        return true;
    653657    }
    654     return positionFromTwoValues(value1, value2, resultX, resultY);
     658    return positionFromTwoValues(*value1, *value2, resultX, resultY);
    655659}
    656660
    657661// This should go away once we drop support for -webkit-gradient
    658 static CSSPrimitiveValue* consumeDeprecatedGradientPoint(CSSParserTokenRange& args, bool horizontal)
     662static RefPtr<CSSPrimitiveValue> consumeDeprecatedGradientPoint(CSSParserTokenRange& args, bool horizontal)
    659663{
    660664    if (args.peek().type() == IdentToken) {
    661665        if ((horizontal && consumeIdent<CSSValueLeft>(args)) || (!horizontal && consumeIdent<CSSValueTop>(args)))
    662             return CSSPrimitiveValue::create(0., CSSPrimitiveValue::UnitType::Percentage);
     666            return CSSPrimitiveValue::create(0., CSSPrimitiveValue::UnitTypes::CSS_PERCENTAGE);
    663667        if ((horizontal && consumeIdent<CSSValueRight>(args)) || (!horizontal && consumeIdent<CSSValueBottom>(args)))
    664             return CSSPrimitiveValue::create(100., CSSPrimitiveValue::UnitType::Percentage);
     668            return CSSPrimitiveValue::create(100., CSSPrimitiveValue::UnitTypes::CSS_PERCENTAGE);
    665669        if (consumeIdent<CSSValueCenter>(args))
    666             return CSSPrimitiveValue::create(50., CSSPrimitiveValue::UnitType::Percentage);
    667         return nullptr;
    668     }
    669     CSSPrimitiveValue* result = consumePercent(args, ValueRangeAll);
     670            return CSSPrimitiveValue::create(50., CSSPrimitiveValue::UnitTypes::CSS_PERCENTAGE);
     671        return nullptr;
     672    }
     673    RefPtr<CSSPrimitiveValue> result = consumePercent(args, ValueRangeAll);
    670674    if (!result)
    671675        result = consumeNumber(args, ValueRangeAll);
    … …  
    674678
    675679// Used to parse colors for -webkit-gradient(...).
    676 static CSSValue* consumeDeprecatedGradientStopColor(CSSParserTokenRange& args, CSSParserMode cssParserMode)
     680static RefPtr<CSSPrimitiveValue> consumeDeprecatedGradientStopColor(CSSParserTokenRange& args, CSSParserMode cssParserMode)
    677681{
    678682    if (args.peek().id() == CSSValueCurrentcolor)
    … …  
    692696        position = (id == CSSValueFrom) ? 0 : 1;
    693697    } else {
    694         DCHECK(id == CSSValueColorStop);
     698        ASSERT(id == CSSValueColorStop);
    695699        const CSSParserToken& arg = args.consumeIncludingWhitespace();
    696700        if (arg.type() == PercentageToken)
    … …  
    705709    }
    706710
    707     stop.m_position = CSSPrimitiveValue::create(position, CSSPrimitiveValue::UnitType::Number);
     711    stop.m_position = CSSPrimitiveValue::create(position, CSSPrimitiveValue::UnitTypes::CSS_NUMBER);
    708712    stop.m_color = consumeDeprecatedGradientStopColor(args, cssParserMode);
    709713    return stop.m_color && args.atEnd();
    710714}
    711715
    712 static CSSValue* consumeDeprecatedGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode)
    713 {
    714     CSSGradientValue* result = nullptr;
     716static RefPtr<CSSValue> consumeDeprecatedGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode)
     717{
     718    RefPtr<CSSGradientValue> result;
    715719    CSSValueID id = args.consumeIncludingWhitespace().id();
    716720    bool isDeprecatedRadialGradient = (id == CSSValueRadial);
    … …  
    722726        return nullptr;
    723727
    724     CSSPrimitiveValue* point = consumeDeprecatedGradientPoint(args, true);
     728    RefPtr<CSSPrimitiveValue> point = consumeDeprecatedGradientPoint(args, true);
    725729    if (!point)
    726730        return nullptr;
    727     result->setFirstX(point);
     731    result->setFirstX(WTFMove(point));
    728732    point = consumeDeprecatedGradientPoint(args, false);
    729733    if (!point)
    730734        return nullptr;
    731     result->setFirstY(point);
     735    result->setFirstY(WTFMove(point));
    732736
    733737    if (!consumeCommaIncludingWhitespace(args))
    … …  
    736740    // For radial gradients only, we now expect a numeric radius.
    737741    if (isDeprecatedRadialGradient) {
    738         CSSPrimitiveValue* radius = consumeNumber(args, ValueRangeAll);
     742        RefPtr<CSSPrimitiveValue> radius = consumeNumber(args, ValueRangeAll);
    739743        if (!radius || !consumeCommaIncludingWhitespace(args))
    740744            return nullptr;
    741         toCSSRadialGradientValue(result)->setFirstRadius(radius);
     745        downcast<CSSRadialGradientValue>(result.get())->setFirstRadius(WTFMove(radius));
    742746    }
    743747
    … …  
    745749    if (!point)
    746750        return nullptr;
    747     result->setSecondX(point);
     751    result->setSecondX(WTFMove(point));
    748752    point = consumeDeprecatedGradientPoint(args, false);
    749753    if (!point)
    750754        return nullptr;
    751     result->setSecondY(point);
     755    result->setSecondY(WTFMove(point));
    752756
    753757    // For radial gradients only, we now expect the second radius.
    … …  
    755759        if (!consumeCommaIncludingWhitespace(args))
    756760            return nullptr;
    757         CSSPrimitiveValue* radius = consumeNumber(args, ValueRangeAll);
     761        RefPtr<CSSPrimitiveValue> radius = consumeNumber(args, ValueRangeAll);
    758762        if (!radius)
    759763            return nullptr;
    760         toCSSRadialGradientValue(result)->setSecondRadius(radius);
     764        downcast<CSSRadialGradientValue>(result.get())->setSecondRadius(WTFMove(radius));
    761765    }
    762766
    … …  
    798802}
    799803
    800 static CSSValue* consumeDeprecatedRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
    801 {
    802     CSSRadialGradientValue* result = CSSRadialGradientValue::create(repeating, CSSPrefixedRadialGradient);
    803     CSSValue* centerX = nullptr;
    804     CSSValue* centerY = nullptr;
     804static RefPtr<CSSValue> consumeDeprecatedRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
     805{
     806    RefPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSPrefixedRadialGradient);
     807    RefPtr<CSSPrimitiveValue> centerX;
     808    RefPtr<CSSPrimitiveValue> centerY;
    805809    consumeOneOrTwoValuedPosition(args, cssParserMode, UnitlessQuirk::Forbid, centerX, centerY);
    806810    if ((centerX || centerY) && !consumeCommaIncludingWhitespace(args))
    807811        return nullptr;
    808812
    809     result->setFirstX(toCSSPrimitiveValue(centerX));
    810     result->setSecondX(toCSSPrimitiveValue(centerX));
    811     result->setFirstY(toCSSPrimitiveValue(centerY));
    812     result->setSecondY(toCSSPrimitiveValue(centerY));
    813 
    814     CSSPrimitiveValue* shape = consumeIdent<CSSValueCircle, CSSValueEllipse>(args);
    815     CSSPrimitiveValue* sizeKeyword = consumeIdent<CSSValueClosestSide, CSSValueClosestCorner, CSSValueFarthestSide, CSSValueFarthestCorner, CSSValueContain, CSSValueCover>(args);
     813    result->setFirstX(WTFMove(centerX));
     814    result->setFirstY(WTFMove(centerY));
     815    result->setSecondX(WTFMove(centerX));
     816    result->setSecondY(WTFMove(centerY));
     817
     818    RefPtr<CSSPrimitiveValue> shape = consumeIdent<CSSValueCircle, CSSValueEllipse>(args);
     819    RefPtr<CSSPrimitiveValue> sizeKeyword = consumeIdent<CSSValueClosestSide, CSSValueClosestCorner, CSSValueFarthestSide, CSSValueFarthestCorner, CSSValueContain, CSSValueCover>(args);
    816820    if (!shape)
    817821        shape = consumeIdent<CSSValueCircle, CSSValueEllipse>(args);
    818     result->setShape(shape);
    819     result->setSizingBehavior(sizeKeyword);
     822    result->setShape(WTFMove(shape));
     823    result->setSizingBehavior(WTFMove(sizeKeyword));
    820824
    821825    // Or, two lengths or percentages
    822826    if (!shape && !sizeKeyword) {
    823         CSSPrimitiveValue* horizontalSize = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
    824         CSSPrimitiveValue* verticalSize = nullptr;
     827        RefPtr<CSSPrimitiveValue> horizontalSize = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
     828        RefPtr<CSSPrimitiveValue> verticalSize;
    825829        if (horizontalSize) {
    826830            verticalSize = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
    … …  
    828832                return nullptr;
    829833            consumeCommaIncludingWhitespace(args);
    830             result->setEndHorizontalSize(horizontalSize);
    831             result->setEndVerticalSize(verticalSize);
     834            result->setEndHorizontalSize(WTFMove(horizontalSize));
     835            result->setEndVerticalSize(WTFMove(verticalSize));
    832836        }
    833837    } else {
    834838        consumeCommaIncludingWhitespace(args);
    835839    }
    836     if (!consumeGradientColorStops(args, cssParserMode, result))
     840    if (!consumeGradientColorStops(args, cssParserMode, result.get()))
    837841        return nullptr;
    838842
    … …  
    840844}
    841845
    842 static CSSValue* consumeRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
    843 {
    844     CSSRadialGradientValue* result = CSSRadialGradientValue::create(repeating, CSSRadialGradient);
    845 
    846     CSSPrimitiveValue* shape = nullptr;
    847     CSSPrimitiveValue* sizeKeyword = nullptr;
    848     CSSPrimitiveValue* horizontalSize = nullptr;
    849     CSSPrimitiveValue* verticalSize = nullptr;
     846static RefPtr<CSSValue> consumeRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
     847{
     848    RefPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSRadialGradient);
     849
     850    RefPtr<CSSPrimitiveValue> shape;
     851    RefPtr<CSSPrimitiveValue> sizeKeyword;
     852    RefPtr<CSSPrimitiveValue> horizontalSize;
     853    RefPtr<CSSPrimitiveValue> verticalSize;
    850854
    851855    // First part of grammar, the size/shape clause:
    … …  
    868872            }
    869873        } else {
    870             CSSPrimitiveValue* center = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
     874            RefPtr<CSSPrimitiveValue> center = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
    871875            if (!center)
    872876                break;
    … …  
    898902        return nullptr;
    899903
    900     result->setShape(shape);
    901     result->setSizingBehavior(sizeKeyword);
    902     result->setEndHorizontalSize(horizontalSize);
    903     result->setEndVerticalSize(verticalSize);
    904 
    905     CSSValue* centerX = nullptr;
    906     CSSValue* centerY = nullptr;
     904    result->setShape(WTFMove(shape));
     905    result->setSizingBehavior(WTFMove(sizeKeyword));
     906    result->setEndHorizontalSize(WTFMove(horizontalSize));
     907    result->setEndVerticalSize(WTFMove(verticalSize));
     908
     909    RefPtr<CSSPrimitiveValue> centerX;
     910    RefPtr<CSSPrimitiveValue> centerY;
    907911    if (args.peek().id() == CSSValueAt) {
    908912        args.consumeIncludingWhitespace();
    … …  
    910914        if (!(centerX && centerY))
    911915            return nullptr;
    912         result->setFirstX(centerX);
    913         result->setFirstY(centerY);
     916       
     917        result->setFirstX(WTFMove(centerX));
     918        result->setFirstY(WTFMove(centerY));
     919       
    914920        // Right now, CSS radial gradients have the same start and end centers.
    915         result->setSecondX(centerX);
    916         result->setSecondY(centerY);
     921        result->setSecondX(WTFMove(centerX));
     922        result->setSecondY(WTFMove(centerY));
    917923    }
    918924
    919925    if ((shape || sizeKeyword || horizontalSize || centerX || centerY) && !consumeCommaIncludingWhitespace(args))
    920926        return nullptr;
    921     if (!consumeGradientColorStops(args, cssParserMode, result))
     927    if (!consumeGradientColorStops(args, cssParserMode, result.get()))
    922928        return nullptr;
    923929    return result;
    924930}
    925931
    926 static CSSValue* consumeLinearGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating, CSSGradientType gradientType)
    927 {
    928     CSSLinearGradientValue* result = CSSLinearGradientValue::create(repeating, gradientType);
     932static RefPtr<CSSValue> consumeLinearGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating, CSSGradientType gradientType)
     933{
     934    RefPtr<CSSLinearGradientValue> result = CSSLinearGradientValue::create(repeating, gradientType);
    929935
    930936    bool expectComma = true;
    931     CSSPrimitiveValue* angle = consumeAngle(args);
    932     if (angle) {
    933         result->setAngle(angle);
    934     } else if (gradientType == CSSPrefixedLinearGradient || consumeIdent<CSSValueTo>(args)) {
    935         CSSPrimitiveValue* endX = consumeIdent<CSSValueLeft, CSSValueRight>(args);
    936         CSSPrimitiveValue* endY = consumeIdent<CSSValueBottom, CSSValueTop>(args);
     937    RefPtr<CSSPrimitiveValue> angle = consumeAngle(args, cssParserMode, UnitlessQuirk::Forbid);
     938    if (angle)
     939        result->setAngle(angle.releaseNonNull());
     940    else if (gradientType == CSSPrefixedLinearGradient || consumeIdent<CSSValueTo>(args)) {
     941        RefPtr<CSSPrimitiveValue> endX = consumeIdent<CSSValueLeft, CSSValueRight>(args);
     942        RefPtr<CSSPrimitiveValue> endY = consumeIdent<CSSValueBottom, CSSValueTop>(args);
    937943        if (!endX && !endY) {
    938944            if (gradientType == CSSLinearGradient)
    … …  
    944950        }
    945951
    946         result->setFirstX(endX);
    947         result->setFirstY(endY);
     952        result->setFirstX(WTFMove(endX));
     953        result->setFirstY(WTFMove(endY));
    948954    } else {
    949955        expectComma = false;
    … …  
    952958    if (expectComma && !consumeCommaIncludingWhitespace(args))
    953959        return nullptr;
    954     if (!consumeGradientColorStops(args, cssParserMode, result))
     960    if (!consumeGradientColorStops(args, cssParserMode, result.get()))
    955961        return nullptr;
    956962    return result;
    957963}
    958964
    959 CSSValue* consumeImageOrNone(CSSParserTokenRange& range, CSSParserContext context)
     965RefPtr<CSSValue> consumeImageOrNone(CSSParserTokenRange& range, CSSParserContext context)
    960966{
    961967    if (range.peek().id() == CSSValueNone)
    … …  
    964970}
    965971
    966 static CSSValue* consumeCrossFade(CSSParserTokenRange& args, CSSParserContext context)
    967 {
    968     CSSValue* fromImageValue = consumeImageOrNone(args, context);
     972static RefPtr<CSSValue> consumeCrossFade(CSSParserTokenRange& args, CSSParserContext context)
     973{
     974    RefPtr<CSSValue> fromImageValue = consumeImageOrNone(args, context);
    969975    if (!fromImageValue || !consumeCommaIncludingWhitespace(args))
    970976        return nullptr;
    971     CSSValue* toImageValue = consumeImageOrNone(args, context);
     977    RefPtr<CSSValue> toImageValue = consumeImageOrNone(args, context);
    972978    if (!toImageValue || !consumeCommaIncludingWhitespace(args))
    973979        return nullptr;
    974980
    975     CSSPrimitiveValue* percentage = nullptr;
     981    RefPtr<CSSPrimitiveValue> percentage;
    976982    const CSSParserToken& percentageArg = args.consumeIncludingWhitespace();
    977983    if (percentageArg.type() == PercentageToken)
    978         percentage = CSSPrimitiveValue::create(clampTo<double>(percentageArg.numericValue() / 100, 0, 1), CSSPrimitiveValue::UnitType::Number);
     984        percentage = CSSPrimitiveValue::create(clampTo<double>(percentageArg.numericValue() / 100, 0, 1), CSSPrimitiveValue::UnitTypes::CSS_NUMBER);
    979985    else if (percentageArg.type() == NumberToken)
    980         percentage = CSSPrimitiveValue::create(clampTo<double>(percentageArg.numericValue(), 0, 1), CSSPrimitiveValue::UnitType::Number);
     986        percentage = CSSPrimitiveValue::create(clampTo<double>(percentageArg.numericValue(), 0, 1), CSSPrimitiveValue::UnitTypes::CSS_NUMBER);
    981987
    982988    if (!percentage)
    983989        return nullptr;
    984     return CSSCrossfadeValue::create(fromImageValue, toImageValue, percentage);
    985 }
    986 
    987 static CSSValue* consumePaint(CSSParserTokenRange& args, CSSParserContext context)
    988 {
    989     DCHECK(RuntimeEnabledFeatures::cssPaintAPIEnabled());
    990 
    991     CSSCustomIdentValue* name = consumeCustomIdent(args);
    992     if (!name)
    993         return nullptr;
    994 
    995     return CSSPaintValue::create(name);
    996 }
    997 
    998 static CSSValue* consumeGeneratedImage(CSSParserTokenRange& range, CSSParserContext context)
     990    return CSSCrossfadeValue::create(fromImageValue.releaseNonNull(), toImageValue.releaseNonNull(), percentage.releaseNonNull());
     991}
     992
     993static RefPtr<CSSValue> consumeGeneratedImage(CSSParserTokenRange& range, CSSParserContext context)
    999994{
    1000995    CSSValueID id = range.peek().functionId();
    1001996    CSSParserTokenRange rangeCopy = range;
    1002997    CSSParserTokenRange args = consumeFunction(rangeCopy);
    1003     CSSValue* result = nullptr;
    1004     if (id == CSSValueRadialGradient) {
    1005         result = consumeRadialGradient(args, context.mode(), NonRepeating);
    1006     } else if (id == CSSValueRepeatingRadialGradient) {
    1007         result = consumeRadialGradient(args, context.mode(), Repeating);
    1008     } else if (id == CSSValueWebkitLinearGradient) {
    1009         // FIXME: This should send a deprecation message.
    1010         if (context.useCounter())
    1011             context.useCounter()->count(UseCounter::DeprecatedWebKitLinearGradient);
    1012         result = consumeLinearGradient(args, context.mode(), NonRepeating, CSSPrefixedLinearGradient);
    1013     } else if (id == CSSValueWebkitRepeatingLinearGradient) {
    1014         // FIXME: This should send a deprecation message.
    1015         if (context.useCounter())
    1016             context.useCounter()->count(UseCounter::DeprecatedWebKitRepeatingLinearGradient);
    1017         result = consumeLinearGradient(args, context.mode(), Repeating, CSSPrefixedLinearGradient);
    1018     } else if (id == CSSValueRepeatingLinearGradient) {
    1019         result = consumeLinearGradient(args, context.mode(), Repeating, CSSLinearGradient);
    1020     } else if (id == CSSValueLinearGradient) {
    1021         result = consumeLinearGradient(args, context.mode(), NonRepeating, CSSLinearGradient);
    1022     } else if (id == CSSValueWebkitGradient) {
    1023         // FIXME: This should send a deprecation message.
    1024         if (context.useCounter())
    1025             context.useCounter()->count(UseCounter::DeprecatedWebKitGradient);
    1026         result = consumeDeprecatedGradient(args, context.mode());
    1027     } else if (id == CSSValueWebkitRadialGradient) {
    1028         // FIXME: This should send a deprecation message.
    1029         if (context.useCounter())
    1030             context.useCounter()->count(UseCounter::DeprecatedWebKitRadialGradient);
    1031         result = consumeDeprecatedRadialGradient(args, context.mode(), NonRepeating);
    1032     } else if (id == CSSValueWebkitRepeatingRadialGradient) {
    1033         if (context.useCounter())
    1034             context.useCounter()->count(UseCounter::DeprecatedWebKitRepeatingRadialGradient);
    1035         result = consumeDeprecatedRadialGradient(args, context.mode(), Repeating);
    1036     } else if (id == CSSValueWebkitCrossFade) {
     998    RefPtr<CSSValue> result;
     999    if (id == CSSValueRadialGradient)
     1000        result = consumeRadialGradient(args, context.mode, NonRepeating);
     1001    else if (id == CSSValueRepeatingRadialGradient)
     1002        result = consumeRadialGradient(args, context.mode, Repeating);
     1003    else if (id == CSSValueWebkitLinearGradient)
     1004        result = consumeLinearGradient(args, context.mode, NonRepeating, CSSPrefixedLinearGradient);
     1005    else if (id == CSSValueWebkitRepeatingLinearGradient)
     1006        result = consumeLinearGradient(args, context.mode, Repeating, CSSPrefixedLinearGradient);
     1007    else if (id == CSSValueRepeatingLinearGradient)
     1008        result = consumeLinearGradient(args, context.mode, Repeating, CSSLinearGradient);
     1009    else if (id == CSSValueLinearGradient)
     1010        result = consumeLinearGradient(args, context.mode, NonRepeating, CSSLinearGradient);
     1011    else if (id == CSSValueWebkitGradient)
     1012        result = consumeDeprecatedGradient(args, context.mode);
     1013    else if (id == CSSValueWebkitRadialGradient)
     1014        result = consumeDeprecatedRadialGradient(args, context.mode, NonRepeating);
     1015    else if (id == CSSValueWebkitRepeatingRadialGradient)
     1016        result = consumeDeprecatedRadialGradient(args, context.mode, Repeating);
     1017    else if (id == CSSValueWebkitCrossFade)
    10371018        result = consumeCrossFade(args, context);
    1038     } else if (id == CSSValuePaint) {
    1039         result = RuntimeEnabledFeatures::cssPaintAPIEnabled() ? consumePaint(args, context) : nullptr;
    1040     }
     1019
    10411020    if (!result || !args.atEnd())
    10421021        return nullptr;
    … …  
    10451024}
    10461025
    1047 static CSSValue* createCSSImageValueWithReferrer(const AtomicString& rawValue, const CSSParserContext& context)
    1048 {
    1049     CSSValue* imageValue = CSSImageValue::create(rawValue, context.completeURL(rawValue));
    1050     toCSSImageValue(imageValue)->setReferrer(context.referrer());
    1051     return imageValue;
    1052 }
    1053 
    1054 static CSSValue* consumeImageSet(CSSParserTokenRange& range, const CSSParserContext& context)
     1026static RefPtr<CSSValue> consumeImageSet(CSSParserTokenRange& range, const CSSParserContext& context)
    10551027{
    10561028    CSSParserTokenRange rangeCopy = range;
    10571029    CSSParserTokenRange args = consumeFunction(rangeCopy);
    1058     CSSImageSetValue* imageSet = CSSImageSetValue::create();
     1030    RefPtr<CSSImageSetValue> imageSet = CSSImageSetValue::create();
    10591031    do {
    10601032        AtomicString urlValue = consumeUrlAsStringView(args).toAtomicString();
    … …  
    10621034            return nullptr;
    10631035
    1064         CSSValue* image = createCSSImageValueWithReferrer(urlValue, context);
     1036        RefPtr<CSSValue> image = CSSImageValue::create(completeURL(context, urlValue));
    10651037        imageSet->append(*image);
    10661038
    … …  
    10701042        if (token.value() != "x")
    10711043            return nullptr;
    1072         DCHECK(token.unitType() == CSSPrimitiveValue::UnitType::Unknown);
     1044        ASSERT(token.unitType() == CSSPrimitiveValue::UnitTypes::CSS_UNKNOWN);
    10731045        double imageScaleFactor = token.numericValue();
    10741046        if (imageScaleFactor <= 0)
    10751047            return nullptr;
    1076         imageSet->append(*CSSPrimitiveValue::create(imageScaleFactor, CSSPrimitiveValue::UnitType::Number));
     1048        imageSet->append(CSSPrimitiveValue::create(imageScaleFactor, CSSPrimitiveValue::UnitTypes::CSS_NUMBER));
    10771049    } while (consumeCommaIncludingWhitespace(args));
    10781050    if (!args.atEnd())
    … …  
    10911063}
    10921064
    1093 CSSValue* consumeImage(CSSParserTokenRange& range, CSSParserContext context, ConsumeGeneratedImage generatedImage)
     1065RefPtr<CSSValue> consumeImage(CSSParserTokenRange& range, CSSParserContext context, ConsumeGeneratedImage generatedImage)
    10941066{
    10951067    AtomicString uri = consumeUrlAsStringView(range).toAtomicString();
    10961068    if (!uri.isNull())
    1097         return createCSSImageValueWithReferrer(uri, context);
     1069        return CSSImageValue::create(completeURL(context, uri));
    10981070    if (range.peek().type() == FunctionToken) {
    10991071        CSSValueID id = range.peek().functionId();
    … …  
    11071079
    11081080} // namespace CSSPropertyParserHelpers
    1109 */
    11101081
    11111082} // namespace WebCore

  • trunk/Source/WebCore/css/parser/CSSPropertyParserHelpers.h

    r205103 r206043  
    3232#define CSSPropertyParserHelpers_h
    3333
    34 // FIXME-NEWPARSER #include "CSSCustomIdentValue.h"
     34#include "CSSCustomIdentValue.h"
    3535#include "CSSParserMode.h"
    3636#include "CSSParserTokenRange.h"
    … …  
    3939
    4040namespace WebCore {
    41 
    42 class CSSStringValue;
    43 class CSSURIValue;
    44 class CSSValuePair;
    4541
    4642// When these functions are successful, they will consume all the relevant
    … …  
    6157};
    6258
    63 CSSPrimitiveValue* consumeInteger(CSSParserTokenRange&, double minimumValue = -std::numeric_limits<double>::max());
    64 CSSPrimitiveValue* consumePositiveInteger(CSSParserTokenRange&);
     59RefPtr<CSSPrimitiveValue> consumeInteger(CSSParserTokenRange&, double minimumValue = -std::numeric_limits<double>::max());
     60RefPtr<CSSPrimitiveValue> consumePositiveInteger(CSSParserTokenRange&);
    6561bool consumeNumberRaw(CSSParserTokenRange&, double& result);
    66 CSSPrimitiveValue* consumeNumber(CSSParserTokenRange&, ValueRange);
    67 CSSPrimitiveValue* consumeLength(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk = UnitlessQuirk::Forbid);
    68 CSSPrimitiveValue* consumePercent(CSSParserTokenRange&, ValueRange);
    69 CSSPrimitiveValue* consumeLengthOrPercent(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk = UnitlessQuirk::Forbid);
    70 CSSPrimitiveValue* consumeAngle(CSSParserTokenRange&);
    71 CSSPrimitiveValue* consumeTime(CSSParserTokenRange&, ValueRange);
     62RefPtr<CSSPrimitiveValue> consumeNumber(CSSParserTokenRange&, ValueRange);
     63RefPtr<CSSPrimitiveValue> consumeLength(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk = UnitlessQuirk::Forbid);
     64RefPtr<CSSPrimitiveValue> consumePercent(CSSParserTokenRange&, ValueRange);
     65RefPtr<CSSPrimitiveValue> consumeLengthOrPercent(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk = UnitlessQuirk::Forbid);
     66RefPtr<CSSPrimitiveValue> consumeAngle(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk = UnitlessQuirk::Forbid);
     67RefPtr<CSSPrimitiveValue> consumeTime(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk = UnitlessQuirk::Forbid);
    7268
    73 CSSPrimitiveValue* consumeIdent(CSSParserTokenRange&);
    74 CSSPrimitiveValue* consumeIdentRange(CSSParserTokenRange&, CSSValueID lower, CSSValueID upper);
     69RefPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange&);
     70RefPtr<CSSPrimitiveValue> consumeIdentRange(CSSParserTokenRange&, CSSValueID lower, CSSValueID upper);
    7571template<CSSValueID, CSSValueID...> inline bool identMatches(CSSValueID id);
    76 template<CSSValueID... allowedIdents> CSSPrimitiveValue* consumeIdent(CSSParserTokenRange&);
     72template<CSSValueID... allowedIdents> RefPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange&);
    7773
    78 // FIXME-NEWPARSER CSSCustomIdentValue* consumeCustomIdent(CSSParserTokenRange&);
    79 CSSStringValue* consumeString(CSSParserTokenRange&);
     74RefPtr<CSSCustomIdentValue> consumeCustomIdent(CSSParserTokenRange&);
     75RefPtr<CSSPrimitiveValue> consumeString(CSSParserTokenRange&);
    8076StringView consumeUrlAsStringView(CSSParserTokenRange&);
    81 CSSURIValue* consumeUrl(CSSParserTokenRange&);
     77RefPtr<CSSPrimitiveValue> consumeUrl(CSSParserTokenRange&);
    8278
    83 CSSValue* consumeColor(CSSParserTokenRange&, CSSParserMode, bool acceptQuirkyColors = false);
     79RefPtr<CSSPrimitiveValue> consumeColor(CSSParserTokenRange&, CSSParserMode, bool acceptQuirkyColors = false);
    8480
    85 CSSValuePair* consumePosition(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk);
    86 bool consumePosition(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk, CSSValue*& resultX, CSSValue*& resultY);
    87 bool consumeOneOrTwoValuedPosition(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk, CSSValue*& resultX, CSSValue*& resultY);
     81RefPtr<CSSPrimitiveValue> consumePosition(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk);
     82bool consumePosition(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk, RefPtr<CSSPrimitiveValue>& resultX, RefPtr<CSSPrimitiveValue>& resultY);
     83bool consumeOneOrTwoValuedPosition(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk, RefPtr<CSSPrimitiveValue>& resultX, RefPtr<CSSPrimitiveValue>& resultY);
    8884
    8985enum class ConsumeGeneratedImage {
    … …  
    9288};
    9389
    94 CSSValue* consumeImage(CSSParserTokenRange&, CSSParserContext, ConsumeGeneratedImage = ConsumeGeneratedImage::Allow);
    95 CSSValue* consumeImageOrNone(CSSParserTokenRange&, CSSParserContext);
     90RefPtr<CSSValue> consumeImage(CSSParserTokenRange&, CSSParserContext, ConsumeGeneratedImage = ConsumeGeneratedImage::Allow);
     91RefPtr<CSSValue> consumeImageOrNone(CSSParserTokenRange&, CSSParserContext);
    9692
    9793// Template implementations are at the bottom of the file for readability.
    … …  
    113109static inline bool isCSSWideKeyword(const CSSValueID& id)
    114110{
    115     return id == CSSValueInitial || id == CSSValueInherit || id == CSSValueUnset || id == CSSValueDefault;
     111    return id == CSSValueInitial || id == CSSValueInherit || id == CSSValueUnset || id == CSSValueRevert || id == CSSValueDefault;
    116112}
    117113

  • trunk/Source/WebCore/platform/CalculationValue.cpp

    r194496 r206043  
    3737namespace WebCore {
    3838
    39 Ref<CalculationValue> CalculationValue::create(std::unique_ptr<CalcExpressionNode> value, CalculationPermittedValueRange range)
     39Ref<CalculationValue> CalculationValue::create(std::unique_ptr<CalcExpressionNode> value, ValueRange range)
    4040{
    4141    return adoptRef(*new CalculationValue(WTFMove(value), range));

  • trunk/Source/WebCore/platform/CalculationValue.h

    r204466 r206043  
    4747};
    4848
    49 enum CalculationPermittedValueRange {
    50     CalculationRangeAll,
    51     CalculationRangeNonNegative
    52 };
    53 
    5449enum CalcExpressionNodeType {
    5550    CalcExpressionNodeUndefined,
    … …  
    137132class CalculationValue : public RefCounted<CalculationValue> {
    138133public:
    139     WEBCORE_EXPORT static Ref<CalculationValue> create(std::unique_ptr<CalcExpressionNode>, CalculationPermittedValueRange);
     134    WEBCORE_EXPORT static Ref<CalculationValue> create(std::unique_ptr<CalcExpressionNode>, ValueRange);
    140135    float evaluate(float maxValue) const;
    141136
    … …  
    144139
    145140private:
    146     CalculationValue(std::unique_ptr<CalcExpressionNode>, CalculationPermittedValueRange);
     141    CalculationValue(std::unique_ptr<CalcExpressionNode>, ValueRange);
    147142
    148143    std::unique_ptr<CalcExpressionNode> m_expression;
    … …  
    155150}
    156151
    157 inline CalculationValue::CalculationValue(std::unique_ptr<CalcExpressionNode> expression, CalculationPermittedValueRange range)
     152inline CalculationValue::CalculationValue(std::unique_ptr<CalcExpressionNode> expression, ValueRange range)
    158153    : m_expression(WTFMove(expression))
    159     , m_shouldClampToNonNegative(range == CalculationRangeNonNegative)
     154    , m_shouldClampToNonNegative(range == ValueRangeNonNegative)
    160155{
    161156}

  • trunk/Source/WebCore/platform/Length.cpp

    r205659 r206043  
    294294       
    295295    auto blend = std::make_unique<CalcExpressionBlendLength>(from, to, progress);
    296     return Length(CalculationValue::create(WTFMove(blend), CalculationRangeAll));
     296    return Length(CalculationValue::create(WTFMove(blend), ValueRangeAll));
    297297}
    298298

  • trunk/Source/WebCore/platform/graphics/Color.cpp

    r205841 r206043  
    205205}
    206206
     207bool Color::parseHexColor(const StringView& name, RGBA32& rgb)
     208{
     209    unsigned length = name.length();
     210    if (!length)
     211        return false;
     212    if (name.is8Bit())
     213        return parseHexColor(name.characters8(), name.length(), rgb);
     214    return parseHexColor(name.characters16(), name.length(), rgb);
     215}
     216
    207217int differenceSquared(const Color& c1, const Color& c2)
    208218{
    … …  
    227237{
    228238    if (name[0] == '#')
    229         m_valid = parseHexColor(&name[1], m_color);
     239        m_valid = parseHexColor((String)&name[1], m_color);
    230240    else {
    231241        const NamedColor* foundColor = findColor(name, strlen(name));

  • trunk/Source/WebCore/platform/graphics/Color.h

    r205841 r206043  
    176176
    177177    static bool parseHexColor(const String&, RGBA32&);
     178    static bool parseHexColor(const StringView&, RGBA32&);
    178179    static bool parseHexColor(const LChar*, unsigned, RGBA32&);
    179180    static bool parseHexColor(const UChar*, unsigned, RGBA32&);

  • trunk/Source/WebCore/rendering/style/BasicShapes.cpp

    r200343 r206043  
    6161    auto rhs = std::make_unique<CalcExpressionLength>(m_length);
    6262    auto op = std::make_unique<CalcExpressionBinaryOperation>(WTFMove(lhs), WTFMove(rhs), CalcSubtract);
    63     m_computedLength = Length(CalculationValue::create(WTFMove(op), CalculationRangeAll));
     63    m_computedLength = Length(CalculationValue::create(WTFMove(op), ValueRangeAll));
    6464}
    6565

  • trunk/Tools/ChangeLog

    r206042 r206043  
     12016-09-16  Dave Hyatt  <hyatt@apple.com>
     2
     3        [CSS Parser] Get CSSPropertyParserHelpers.cpp compiling
     4        https://bugs.webkit.org/show_bug.cgi?id=162078
     5
     6        Reviewed by Dean Jackson.
     7
     8        * TestWebKitAPI/Tests/WebCore/CalculationValue.cpp:
     9        (TestWebKitAPI::createTestValue):
     10        Convert to ValueRange.
     11
    1122016-09-16  Alex Christensen  <achristensen@webkit.org>
    213

  • trunk/Tools/TestWebKitAPI/Tests/WebCore/CalculationValue.cpp

    r197563 r206043  
    4646{
    4747    auto node = std::make_unique<CalculationDeletionTestNode>();
    48     return WebCore::CalculationValue::create(WTFMove(node), WebCore::CalculationRangeAll);
     48    return WebCore::CalculationValue::create(WTFMove(node), WebCore::ValueRangeAll);
    4949}
    5050
Note: See TracChangeset for help on using the changeset viewer.