⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 276550 in webkit


Ignore:
Timestamp:
Apr 24, 2021, 9:02:06 AM (5 years ago)
Author:
commit-queue@webkit.org
Message:

Refactor ValueRange from enum to enum class
​https://bugs.webkit.org/show_bug.cgi?id=224981

Patch by Tyler Wilcock <Tyler Wilcock> on 2021-04-24
Reviewed by Sam Weinig.

Source/WebCore:

Refactor ValueRange from:

enum ValueRange {

ValueRangeAll,
ValueRangeNonNegative

}

to:

enum ValueRange : uint8_t {

All,
NonNegative

}

making it smaller (one byte versus four) and harder to misuse (no
auto-coercion to number types).

  • animation/CSSPropertyAnimation.cpp:

(WebCore::blendFunc):
Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
and ValueRange::NonNegative.

  • css/CSSCalculationValue.cpp:

(WebCore::CSSCalcValue::create):
Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
and ValueRange::NonNegative.

  • css/CSSCalculationValue.h:

(WebCore::CSSCalcValue::createCalculationValue const):
(WebCore::CSSCalcValue::setPermittedValueRange):
Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
and ValueRange::NonNegative.

  • css/MediaQueryExpression.cpp:

(WebCore::consumeFirstValue):
Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
and ValueRange::NonNegative.

  • css/parser/CSSPropertyParser.cpp:

(WebCore::CSSPropertyParser::consumeTransformOrigin):
(WebCore::consumeLetterSpacing):
(WebCore::consumeWordSpacing):
(WebCore::consumeTabSize):
(WebCore::consumeTextSizeAdjust):
(WebCore::consumeFontSize):
(WebCore::consumeLineHeight):
(WebCore::consumeSize):
(WebCore::consumeTextIndent):
(WebCore::consumeScrollPadding):
(WebCore::consumeMaxWidthOrHeight):
(WebCore::consumeWidthOrHeight):
(WebCore::consumeMarginOrOffset):
(WebCore::consumeClipComponent):
(WebCore::consumeLineClamp):
(WebCore::consumeHyphenateLimit):
(WebCore::consumeColumnWidth):
(WebCore::consumeGapLength):
(WebCore::consumeZoom):
(WebCore::consumeAnimationIterationCount):
(WebCore::consumeAnimationValue):
(WebCore::consumeLineWidth):
(WebCore::consumeTranslate3d):
(WebCore::consumeNumbers):
(WebCore::consumePerspective):
(WebCore::consumeTransformValue):
(WebCore::consumeTranslate):
(WebCore::consumeScale):
(WebCore::consumeRotate):
(WebCore::consumePositionLonghand):
(WebCore::consumeFlexBasis):
(WebCore::consumeKerning):
(WebCore::consumeStrokeDasharray):
(WebCore::consumeBaselineShift):
(WebCore::consumeRxOrRy):
(WebCore::consumeBorderRadiusCorner):
(WebCore::consumeTextUnderlineOffset):
(WebCore::consumeTextDecorationThickness):
(WebCore::consumeVerticalAlign):
(WebCore::consumeShapeRadius):
(WebCore::consumeBasicShapePolygon):
(WebCore::consumeRadii):
(WebCore::consumeBasicShapeInset):
(WebCore::consumeBorderImageSlice):
(WebCore::consumeBorderImageOutset):
(WebCore::consumeBorderImageWidth):
(WebCore::consumeReflect):
(WebCore::consumeBackgroundSize):
(WebCore::consumeFitContent):
(WebCore::consumeGridBreadth):
(WebCore::consumeInitialLetter):
(WebCore::consumeWebkitMarqueeIncrement):
(WebCore::consumeWebkitMarqueeRepetition):
(WebCore::consumeWebkitMarqueeSpeed):
(WebCore::consumeAspectRatio):
(WebCore::CSSPropertyParser::parseSingleValue):
(WebCore::CSSPropertyParser::consumeBorderSpacing):
(WebCore::CSSPropertyParser::consumeFlex):
Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
and ValueRange::NonNegative.

  • css/parser/CSSPropertyParserHelpers.cpp:

(WebCore::CSSPropertyParserHelpers::consumeNumberOrPercentDividedBy100Raw):
(WebCore::CSSPropertyParserHelpers::CalcParser::CalcParser):
(WebCore::CSSPropertyParserHelpers::consumeNumberRaw):
(WebCore::CSSPropertyParserHelpers::consumeFontWeightNumberRaw):
(WebCore::CSSPropertyParserHelpers::consumeLengthRaw):
(WebCore::CSSPropertyParserHelpers::consumePercentRaw):
(WebCore::CSSPropertyParserHelpers::consumeAngleRaw):
(WebCore::CSSPropertyParserHelpers::consumeAngleWorkerSafe):
(WebCore::CSSPropertyParserHelpers::consumeTime):
(WebCore::CSSPropertyParserHelpers::consumePositionComponent):
(WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientPoint):
(WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradient):
(WebCore::CSSPropertyParserHelpers::consumeGradientColorStops):
(WebCore::CSSPropertyParserHelpers::consumeDeprecatedRadialGradient):
(WebCore::CSSPropertyParserHelpers::consumeRadialGradient):
(WebCore::CSSPropertyParserHelpers::consumeFilterFunction):
(WebCore::CSSPropertyParserHelpers::consumeSingleShadow):
(WebCore::CSSPropertyParserHelpers::consumeFontSizeRaw):
(WebCore::CSSPropertyParserHelpers::consumeLineHeightRaw):
Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
and ValueRange::NonNegative.

  • css/parser/CSSPropertyParserHelpers.h:

Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
and ValueRange::NonNegative.

  • css/parser/CSSPropertyParserWorkerSafe.cpp:

(WebCore::CSSPropertyParserHelpersWorkerSafe::consumeFontStretch):
(WebCore::CSSPropertyParserHelpersWorkerSafe::consumeFontStretchRange):
Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
and ValueRange::NonNegative.

  • page/IntersectionObserver.cpp:

(WebCore::parseRootMargin):
Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
and ValueRange::NonNegative.

  • platform/CalculationValue.h:

(WebCore::CalculationValue::CalculationValue):
Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
and ValueRange::NonNegative.

  • platform/Length.cpp:

(WebCore::convertTo100PercentMinusLength):
(WebCore::blendMixedTypes):
(WebCore::blend):
Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
and ValueRange::NonNegative.

  • platform/Length.h:

Refactor enum ValueRange to enum class ValueRange.

  • style/StyleBuilderConverter.h:

(WebCore::Style::BuilderConverter::convertTo100PercentMinusLength):
Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
and ValueRange::NonNegative.

Tools:

ValueRange has been refactored from enum to enum class : uint8_t to
make it smaller and harder to misuse.

  • TestWebKitAPI/Tests/WebCore/CalculationValue.cpp:

(TestWebKitAPI::createTestValue):
Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
and ValueRange::NonNegative.

Location:
trunk
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r276549 r276550  
     12021-04-24  Tyler Wilcock  <twilco.o@protonmail.com>
     2
     3        Refactor ValueRange from enum to enum class
     4        https://bugs.webkit.org/show_bug.cgi?id=224981
     5
     6        Reviewed by Sam Weinig.
     7
     8        Refactor ValueRange from:
     9
     10        enum ValueRange {
     11            ValueRangeAll,
     12            ValueRangeNonNegative
     13        }
     14
     15        to:
     16
     17        enum ValueRange : uint8_t {
     18            All,
     19            NonNegative
     20        }
     21
     22        making it smaller (one byte versus four) and harder to misuse (no
     23        auto-coercion to number types).
     24
     25        * animation/CSSPropertyAnimation.cpp:
     26        (WebCore::blendFunc):
     27        Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
     28        and ValueRange::NonNegative.
     29
     30        * css/CSSCalculationValue.cpp:
     31        (WebCore::CSSCalcValue::create):
     32        Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
     33        and ValueRange::NonNegative.
     34
     35        * css/CSSCalculationValue.h:
     36        (WebCore::CSSCalcValue::createCalculationValue const):
     37        (WebCore::CSSCalcValue::setPermittedValueRange):
     38        Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
     39        and ValueRange::NonNegative.
     40
     41        * css/MediaQueryExpression.cpp:
     42        (WebCore::consumeFirstValue):
     43        Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
     44        and ValueRange::NonNegative.
     45
     46        * css/parser/CSSPropertyParser.cpp:
     47        (WebCore::CSSPropertyParser::consumeTransformOrigin):
     48        (WebCore::consumeLetterSpacing):
     49        (WebCore::consumeWordSpacing):
     50        (WebCore::consumeTabSize):
     51        (WebCore::consumeTextSizeAdjust):
     52        (WebCore::consumeFontSize):
     53        (WebCore::consumeLineHeight):
     54        (WebCore::consumeSize):
     55        (WebCore::consumeTextIndent):
     56        (WebCore::consumeScrollPadding):
     57        (WebCore::consumeMaxWidthOrHeight):
     58        (WebCore::consumeWidthOrHeight):
     59        (WebCore::consumeMarginOrOffset):
     60        (WebCore::consumeClipComponent):
     61        (WebCore::consumeLineClamp):
     62        (WebCore::consumeHyphenateLimit):
     63        (WebCore::consumeColumnWidth):
     64        (WebCore::consumeGapLength):
     65        (WebCore::consumeZoom):
     66        (WebCore::consumeAnimationIterationCount):
     67        (WebCore::consumeAnimationValue):
     68        (WebCore::consumeLineWidth):
     69        (WebCore::consumeTranslate3d):
     70        (WebCore::consumeNumbers):
     71        (WebCore::consumePerspective):
     72        (WebCore::consumeTransformValue):
     73        (WebCore::consumeTranslate):
     74        (WebCore::consumeScale):
     75        (WebCore::consumeRotate):
     76        (WebCore::consumePositionLonghand):
     77        (WebCore::consumeFlexBasis):
     78        (WebCore::consumeKerning):
     79        (WebCore::consumeStrokeDasharray):
     80        (WebCore::consumeBaselineShift):
     81        (WebCore::consumeRxOrRy):
     82        (WebCore::consumeBorderRadiusCorner):
     83        (WebCore::consumeTextUnderlineOffset):
     84        (WebCore::consumeTextDecorationThickness):
     85        (WebCore::consumeVerticalAlign):
     86        (WebCore::consumeShapeRadius):
     87        (WebCore::consumeBasicShapePolygon):
     88        (WebCore::consumeRadii):
     89        (WebCore::consumeBasicShapeInset):
     90        (WebCore::consumeBorderImageSlice):
     91        (WebCore::consumeBorderImageOutset):
     92        (WebCore::consumeBorderImageWidth):
     93        (WebCore::consumeReflect):
     94        (WebCore::consumeBackgroundSize):
     95        (WebCore::consumeFitContent):
     96        (WebCore::consumeGridBreadth):
     97        (WebCore::consumeInitialLetter):
     98        (WebCore::consumeWebkitMarqueeIncrement):
     99        (WebCore::consumeWebkitMarqueeRepetition):
     100        (WebCore::consumeWebkitMarqueeSpeed):
     101        (WebCore::consumeAspectRatio):
     102        (WebCore::CSSPropertyParser::parseSingleValue):
     103        (WebCore::CSSPropertyParser::consumeBorderSpacing):
     104        (WebCore::CSSPropertyParser::consumeFlex):
     105        Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
     106        and ValueRange::NonNegative.
     107
     108        * css/parser/CSSPropertyParserHelpers.cpp:
     109        (WebCore::CSSPropertyParserHelpers::consumeNumberOrPercentDividedBy100Raw):
     110        (WebCore::CSSPropertyParserHelpers::CalcParser::CalcParser):
     111        (WebCore::CSSPropertyParserHelpers::consumeNumberRaw):
     112        (WebCore::CSSPropertyParserHelpers::consumeFontWeightNumberRaw):
     113        (WebCore::CSSPropertyParserHelpers::consumeLengthRaw):
     114        (WebCore::CSSPropertyParserHelpers::consumePercentRaw):
     115        (WebCore::CSSPropertyParserHelpers::consumeAngleRaw):
     116        (WebCore::CSSPropertyParserHelpers::consumeAngleWorkerSafe):
     117        (WebCore::CSSPropertyParserHelpers::consumeTime):
     118        (WebCore::CSSPropertyParserHelpers::consumePositionComponent):
     119        (WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientPoint):
     120        (WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradient):
     121        (WebCore::CSSPropertyParserHelpers::consumeGradientColorStops):
     122        (WebCore::CSSPropertyParserHelpers::consumeDeprecatedRadialGradient):
     123        (WebCore::CSSPropertyParserHelpers::consumeRadialGradient):
     124        (WebCore::CSSPropertyParserHelpers::consumeFilterFunction):
     125        (WebCore::CSSPropertyParserHelpers::consumeSingleShadow):
     126        (WebCore::CSSPropertyParserHelpers::consumeFontSizeRaw):
     127        (WebCore::CSSPropertyParserHelpers::consumeLineHeightRaw):
     128        Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
     129        and ValueRange::NonNegative.
     130
     131        * css/parser/CSSPropertyParserHelpers.h:
     132        Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
     133        and ValueRange::NonNegative.
     134
     135        * css/parser/CSSPropertyParserWorkerSafe.cpp:
     136        (WebCore::CSSPropertyParserHelpersWorkerSafe::consumeFontStretch):
     137        (WebCore::CSSPropertyParserHelpersWorkerSafe::consumeFontStretchRange):
     138        Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
     139        and ValueRange::NonNegative.
     140
     141        * page/IntersectionObserver.cpp:
     142        (WebCore::parseRootMargin):
     143        Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
     144        and ValueRange::NonNegative.
     145
     146        * platform/CalculationValue.h:
     147        (WebCore::CalculationValue::CalculationValue):
     148        Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
     149        and ValueRange::NonNegative.
     150
     151        * platform/Length.cpp:
     152        (WebCore::convertTo100PercentMinusLength):
     153        (WebCore::blendMixedTypes):
     154        (WebCore::blend):
     155        Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
     156        and ValueRange::NonNegative.
     157
     158        * platform/Length.h:
     159        Refactor enum ValueRange to enum class ValueRange.
     160
     161        * style/StyleBuilderConverter.h:
     162        (WebCore::Style::BuilderConverter::convertTo100PercentMinusLength):
     163        Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
     164        and ValueRange::NonNegative.
     165
     166
    11672021-04-24  Zalan Bujtas  <zalan@apple.com>
    2168

  • trunk/Source/WebCore/animation/CSSPropertyAnimation.cpp

    r276465 r276550  
    102102}
    103103
    104 static inline Length blendFunc(const Length& from, const Length& to, const CSSPropertyBlendingContext& context, ValueRange valueRange = ValueRangeAll)
     104static inline Length blendFunc(const Length& from, const Length& to, const CSSPropertyBlendingContext& context, ValueRange valueRange = ValueRange::All)
    105105{
    106106    return blend(from, to, context, valueRange);
    … …  
    111111    if (from.isNormal() || to.isNormal())
    112112        return context.progress < 0.5 ? from : to;
    113     return blend(from.length(), to.length(), context, ValueRangeNonNegative);
     113    return blend(from.length(), to.length(), context, ValueRange::NonNegative);
    114114}
    115115
    … …  
    122122static inline LengthSize blendFunc(const LengthSize& from, const LengthSize& to, const CSSPropertyBlendingContext& context)
    123123{
    124     return { blendFunc(from.width, to.width, context, ValueRangeNonNegative),
    125              blendFunc(from.height, to.height, context, ValueRangeNonNegative) };
     124    return { blendFunc(from.width, to.width, context, ValueRange::NonNegative),
     125        blendFunc(from.height, to.height, context, ValueRange::NonNegative) };
    126126}
    127127
    … …  
    404404}
    405405
    406 static inline LengthBox blendFunc(const LengthBox& from, const LengthBox& to, const CSSPropertyBlendingContext& context, ValueRange valueRange = ValueRangeNonNegative)
     406static inline LengthBox blendFunc(const LengthBox& from, const LengthBox& to, const CSSPropertyBlendingContext& context, ValueRange valueRange = ValueRange::NonNegative)
    407407{
    408408    LengthBox result(blendFunc(from.top(), to.top(), context, valueRange),
    … …  
    792792    void blend(RenderStyle& destination, const RenderStyle& from, const RenderStyle& to, const CSSPropertyBlendingContext& context) const override
    793793    {
    794         auto valueRange = m_flags.contains(Flags::NegativeLengthsAreInvalid) ? ValueRangeNonNegative : ValueRangeAll;
     794        auto valueRange = m_flags.contains(Flags::NegativeLengthsAreInvalid) ? ValueRange::NonNegative : ValueRange::All;
    795795        (destination.*m_setter)(blendFunc(value(from), value(to), context, valueRange));
    796796    }
    … …  
    899899            return;
    900900        }
    901         auto valueRange = m_flags.contains(Flags::AllowsNegativeValues) ? ValueRangeAll : ValueRangeNonNegative;
     901        auto valueRange = m_flags.contains(Flags::AllowsNegativeValues) ? ValueRange::All : ValueRange::NonNegative;
    902902        (destination.*m_setter)(blendFunc(value(from), value(to), context, valueRange));
    903903    }

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

    r276262 r276550  
    21472147    if (!expression)
    21482148        return nullptr;
    2149     auto result = adoptRef(new CSSCalcValue(expression.releaseNonNull(), range != ValueRangeAll));
     2149    auto result = adoptRef(new CSSCalcValue(expression.releaseNonNull(), range != ValueRange::All));
    21502150    LOG_WITH_STREAM(Calc, stream << "CSSCalcValue::create " << *result);
    21512151    return result;

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

    r276262 r276550  
    123123{
    124124    return CalculationValue::create(m_expression->createCalcExpression(conversionData),
    125         m_shouldClampToNonNegative ? ValueRangeNonNegative : ValueRangeAll);
     125        m_shouldClampToNonNegative ? ValueRange::NonNegative : ValueRange::All);
    126126}
    127127
    128128inline void CSSCalcValue::setPermittedValueRange(ValueRange range)
    129129{
    130     m_shouldClampToNonNegative = range != ValueRangeAll;
     130    m_shouldClampToNonNegative = range != ValueRange::All;
    131131}
    132132

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

    r272121 r276550  
    187187
    188188    if (!featureExpectingPositiveInteger(mediaFeature) && !isAspectRatioFeature(mediaFeature)) {
    189         if (auto value = CSSPropertyParserHelpers::consumeNumber(range, ValueRangeNonNegative))
     189        if (auto value = CSSPropertyParserHelpers::consumeNumber(range, ValueRange::NonNegative))
    190190            return value;
    191191    }
    192192
    193     if (auto value = CSSPropertyParserHelpers::consumeLength(range, HTMLStandardMode, ValueRangeNonNegative))
     193    if (auto value = CSSPropertyParserHelpers::consumeLength(range, HTMLStandardMode, ValueRange::NonNegative))
    194194        return value;
    195195

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

    r276488 r276550  
    357357        m_range.consumeWhitespace();
    358358        bool atEnd = m_range.atEnd();
    359         auto resultZ = consumeLength(m_range, m_context.mode, ValueRangeAll);
     359        auto resultZ = consumeLength(m_range, m_context.mode, ValueRange::All);
    360360        bool hasZ = resultZ;
    361361        if (!hasZ && !atEnd)
    … …  
    977977        return consumeIdent(range);
    978978   
    979     return consumeLength(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
     979    return consumeLength(range, cssParserMode, ValueRange::All, UnitlessQuirk::Allow);
    980980}
    981981
    … …  
    985985        return consumeIdent(range);
    986986   
    987     return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
     987    return consumeLengthOrPercent(range, cssParserMode, ValueRange::All, UnitlessQuirk::Allow);
    988988}
    989989   
    990990static RefPtr<CSSValue> consumeTabSize(CSSParserTokenRange& range, CSSParserMode cssParserMode)
    991991{
    992     auto tabSize = consumeNumber(range, ValueRangeNonNegative);
     992    auto tabSize = consumeNumber(range, ValueRange::NonNegative);
    993993    if (tabSize)
    994994        return tabSize;
    995     return consumeLength(range, cssParserMode, ValueRangeNonNegative);
     995    return consumeLength(range, cssParserMode, ValueRange::NonNegative);
    996996}
    997997
    … …  
    10031003    if (range.peek().id() == CSSValueNone)
    10041004        return consumeIdent(range);
    1005     return consumePercent(range, ValueRangeNonNegative);
     1005    return consumePercent(range, ValueRange::NonNegative);
    10061006}
    10071007#endif
    … …  
    10111011    if (range.peek().id() >= CSSValueXxSmall && range.peek().id() <= CSSValueLarger)
    10121012        return consumeIdent(range);
    1013     return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, unitless);
     1013    return consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative, unitless);
    10141014}
    10151015
    … …  
    10191019        return consumeIdent(range);
    10201020
    1021     RefPtr<CSSPrimitiveValue> lineHeight = consumeNumber(range, ValueRangeNonNegative);
     1021    RefPtr<CSSPrimitiveValue> lineHeight = consumeNumber(range, ValueRange::NonNegative);
    10221022    if (lineHeight)
    10231023        return lineHeight;
    1024     return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
     1024    return consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative);
    10251025}
    10261026
    … …  
    10641064    }
    10651065
    1066     if (RefPtr<CSSValue> width = consumeLength(range, cssParserMode, ValueRangeNonNegative)) {
    1067         RefPtr<CSSValue> height = consumeLength(range, cssParserMode, ValueRangeNonNegative);
     1066    if (RefPtr<CSSValue> width = consumeLength(range, cssParserMode, ValueRange::NonNegative)) {
     1067        RefPtr<CSSValue> height = consumeLength(range, cssParserMode, ValueRange::NonNegative);
    10681068        result->append(width.releaseNonNull());
    10691069        if (height)
    … …  
    10951095    do {
    10961096        if (!lengthOrPercentage) {
    1097             if (RefPtr<CSSValue> textIndent = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow)) {
     1097            if (RefPtr<CSSValue> textIndent = consumeLengthOrPercent(range, cssParserMode, ValueRange::All, UnitlessQuirk::Allow)) {
    10981098                lengthOrPercentage = textIndent;
    10991099                continue;
    … …  
    11321132    if (range.peek().id() == CSSValueAuto)
    11331133        return consumeIdent(range);
    1134     return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
     1134    return consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative);
    11351135}
    11361136
    … …  
    11471147    if (range.peek().id() == CSSValueNone || validWidthOrHeightKeyword(range.peek().id(), context))
    11481148        return consumeIdent(range);
    1149     return consumeLengthOrPercent(range, context.mode, ValueRangeNonNegative, unitless);
     1149    return consumeLengthOrPercent(range, context.mode, ValueRange::NonNegative, unitless);
    11501150}
    11511151
    … …  
    11541154    if (range.peek().id() == CSSValueAuto || validWidthOrHeightKeyword(range.peek().id(), context))
    11551155        return consumeIdent(range);
    1156     return consumeLengthOrPercent(range, context.mode, ValueRangeNonNegative, unitless);
     1156    return consumeLengthOrPercent(range, context.mode, ValueRange::NonNegative, unitless);
    11571157}
    11581158
    … …  
    11611161    if (range.peek().id() == CSSValueAuto)
    11621162        return consumeIdent(range);
    1163     return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, unitless);
     1163    return consumeLengthOrPercent(range, cssParserMode, ValueRange::All, unitless);
    11641164}
    11651165
    … …  
    11681168    if (range.peek().id() == CSSValueAuto)
    11691169        return consumeIdent(range);
    1170     return consumeLength(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
     1170    return consumeLength(range, cssParserMode, ValueRange::All, UnitlessQuirk::Allow);
    11711171}
    11721172
    … …  
    12261226static RefPtr<CSSPrimitiveValue> consumeLineClamp(CSSParserTokenRange& range)
    12271227{
    1228     if (auto clampValue = consumePercent(range, ValueRangeNonNegative))
     1228    if (auto clampValue = consumePercent(range, ValueRange::NonNegative))
    12291229        return clampValue;
    12301230    // When specifying number of lines, don't allow 0 as a valid value.
    … …  
    12431243    if (range.peek().id() == valueID)
    12441244        return consumeIdent(range);
    1245     return consumeNumber(range, ValueRangeNonNegative);
     1245    return consumeNumber(range, ValueRange::NonNegative);
    12461246}
    12471247
    … …  
    12521252    // Always parse lengths in strict mode here, since it would be ambiguous otherwise when used in
    12531253    // the 'columns' shorthand property.
    1254     RefPtr<CSSPrimitiveValue> columnWidth = consumeLength(range, HTMLStandardMode, ValueRangeNonNegative);
     1254    RefPtr<CSSPrimitiveValue> columnWidth = consumeLength(range, HTMLStandardMode, ValueRange::NonNegative);
    12551255    if (!columnWidth || columnWidth->isZero().valueOr(false))
    12561256        return nullptr;
    … …  
    12701270    if (range.peek().id() == CSSValueNormal)
    12711271        return consumeIdent(range);
    1272     return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
     1272    return consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative);
    12731273}
    12741274
    … …  
    12851285        zoom = consumeIdent<CSSValueNormal, CSSValueReset, CSSValueDocument>(range);
    12861286    else {
    1287         zoom = consumePercent(range, ValueRangeNonNegative);
     1287        zoom = consumePercent(range, ValueRange::NonNegative);
    12881288        if (!zoom)
    1289             zoom = consumeNumber(range, ValueRangeNonNegative);
     1289            zoom = consumeNumber(range, ValueRange::NonNegative);
    12901290    }
    12911291    return zoom;
    … …  
    12961296    if (range.peek().id() == CSSValueInfinite)
    12971297        return consumeIdent(range);
    1298     return consumeNumber(range, ValueRangeNonNegative);
     1298    return consumeNumber(range, ValueRange::NonNegative);
    12991299}
    13001300
    … …  
    15021502    case CSSPropertyAnimationDelay:
    15031503    case CSSPropertyTransitionDelay:
    1504         return consumeTime(range, context.mode, ValueRangeAll, UnitlessQuirk::Forbid);
     1504        return consumeTime(range, context.mode, ValueRange::All, UnitlessQuirk::Forbid);
    15051505    case CSSPropertyAnimationDirection:
    15061506        return consumeIdent<CSSValueNormal, CSSValueAlternate, CSSValueReverse, CSSValueAlternateReverse>(range);
    15071507    case CSSPropertyAnimationDuration:
    15081508    case CSSPropertyTransitionDuration:
    1509         return consumeTime(range, context.mode, ValueRangeNonNegative, UnitlessQuirk::Forbid);
     1509        return consumeTime(range, context.mode, ValueRange::NonNegative, UnitlessQuirk::Forbid);
    15101510    case CSSPropertyAnimationFillMode:
    15111511        return consumeIdent<CSSValueNone, CSSValueForwards, CSSValueBackwards, CSSValueBoth>(range);
    … …  
    17311731    if (id == CSSValueThin || id == CSSValueMedium || id == CSSValueThick)
    17321732        return consumeIdent(range);
    1733     return consumeLength(range, cssParserMode, ValueRangeNonNegative, unitless);
     1733    return consumeLength(range, cssParserMode, ValueRange::NonNegative, unitless);
    17341734}
    17351735
    … …  
    17541754    RefPtr<CSSValue> parsedValue;
    17551755    do {
    1756         parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
     1756        parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRange::All);
    17571757        if (!parsedValue)
    17581758            return false;
    … …  
    17611761            return false;
    17621762    } while (--numberOfArguments);
    1763     parsedValue = consumeLength(args, cssParserMode, ValueRangeAll);
     1763    parsedValue = consumeLength(args, cssParserMode, ValueRange::All);
    17641764    if (!parsedValue)
    17651765        return false;
    … …  
    17711771{
    17721772    do {
    1773         RefPtr<CSSPrimitiveValue> parsedValue = consumeNumber(args, ValueRangeAll);
     1773        RefPtr<CSSPrimitiveValue> parsedValue = consumeNumber(args, ValueRange::All);
    17741774        if (!parsedValue)
    17751775            return false;
    … …  
    17831783static bool consumePerspective(CSSParserTokenRange& args, CSSParserMode cssParserMode, RefPtr<CSSFunctionValue>& transformValue)
    17841784{
    1785     if (auto parsedValue = consumeLength(args, cssParserMode, ValueRangeNonNegative)) {
     1785    if (auto parsedValue = consumeLength(args, cssParserMode, ValueRange::NonNegative)) {
    17861786        transformValue->append(parsedValue.releaseNonNull());
    17871787        return true;
    … …  
    18281828    case CSSValueScaleZ:
    18291829    case CSSValueScale:
    1830         parsedValue = consumeNumber(args, ValueRangeAll);
     1830        parsedValue = consumeNumber(args, ValueRange::All);
    18311831        if (!parsedValue)
    18321832            return nullptr;
    18331833        if (functionId == CSSValueScale && consumeCommaIncludingWhitespace(args)) {
    18341834            transformValue->append(*parsedValue);
    1835             parsedValue = consumeNumber(args, ValueRangeAll);
     1835            parsedValue = consumeNumber(args, ValueRange::All);
    18361836            if (!parsedValue)
    18371837                return nullptr;
    … …  
    18451845    case CSSValueTranslateY:
    18461846    case CSSValueTranslate:
    1847         parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
     1847        parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRange::All);
    18481848        if (!parsedValue)
    18491849            return nullptr;
    18501850        if (functionId == CSSValueTranslate && consumeCommaIncludingWhitespace(args)) {
    18511851            transformValue->append(*parsedValue);
    1852             parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
     1852            parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRange::All);
    18531853            if (!parsedValue)
    18541854                return nullptr;
    … …  
    18561856        break;
    18571857    case CSSValueTranslateZ:
    1858         parsedValue = consumeLength(args, cssParserMode, ValueRangeAll);
     1858        parsedValue = consumeLength(args, cssParserMode, ValueRange::All);
    18591859        break;
    18601860    case CSSValueMatrix:
    … …  
    19181918    // translate3d() function.
    19191919
    1920     RefPtr<CSSValue> x = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll);
     1920    RefPtr<CSSValue> x = consumeLengthOrPercent(range, cssParserMode, ValueRange::All);
    19211921    if (!x)
    19221922        return list;
    … …  
    19261926
    19271927    range.consumeWhitespace();
    1928     RefPtr<CSSValue> y = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll);
     1928    RefPtr<CSSValue> y = consumeLengthOrPercent(range, cssParserMode, ValueRange::All);
    19291929    if (!y)
    19301930        return list;
    … …  
    19391939
    19401940    range.consumeWhitespace();
    1941     RefPtr<CSSValue> z = consumeLength(range, cssParserMode, ValueRangeAll);
     1941    RefPtr<CSSValue> z = consumeLength(range, cssParserMode, ValueRange::All);
    19421942
    19431943    if (is<CSSPrimitiveValue>(z)) {
    … …  
    19711971    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
    19721972
    1973     RefPtr<CSSValue> x = consumeNumber(range, ValueRangeAll);
     1973    RefPtr<CSSValue> x = consumeNumber(range, ValueRange::All);
    19741974    if (!x)
    19751975        return list;
    … …  
    19771977    range.consumeWhitespace();
    19781978
    1979     RefPtr<CSSValue> y = consumeNumber(range, ValueRangeAll);
     1979    RefPtr<CSSValue> y = consumeNumber(range, ValueRange::All);
    19801980    if (!y)
    19811981        return list;
    … …  
    19861986    range.consumeWhitespace();
    19871987
    1988     RefPtr<CSSValue> z = consumeNumber(range, ValueRangeAll);
     1988    RefPtr<CSSValue> z = consumeNumber(range, ValueRange::All);
    19891989    if (!z)
    19901990        return list;
    … …  
    20242024    while (!range.atEnd()) {
    20252025        // First, attempt to parse a number, which might be in a series of 3 specifying the rotation axis.
    2026         RefPtr<CSSValue> parsedValue = consumeNumber(range, ValueRangeAll);
     2026        RefPtr<CSSValue> parsedValue = consumeNumber(range, ValueRange::All);
    20272027        if (parsedValue) {
    20282028            // If we've encountered an axis identifier, then this valus is invalid.
    … …  
    21132113        return CSSPrimitiveValue::create(percent, CSSUnitType::CSS_PERCENTAGE);
    21142114    }
    2115     return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll);
     2115    return consumeLengthOrPercent(range, cssParserMode, ValueRange::All);
    21162116}
    21172117
    … …  
    22212221    if (range.peek().id() == CSSValueAuto)
    22222222        return consumeIdent(range);
    2223     return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
     2223    return consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative);
    22242224}
    22252225
    … …  
    22292229    if (result)
    22302230        return result;
    2231     return consumeLength(range, mode, ValueRangeAll, UnitlessQuirk::Allow);
     2231    return consumeLength(range, mode, ValueRange::All, UnitlessQuirk::Allow);
    22322232}
    22332233
    … …  
    22402240    RefPtr<CSSValueList> dashes = CSSValueList::createCommaSeparated();
    22412241    do {
    2242         RefPtr<CSSPrimitiveValue> dash = consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeNonNegative);
     2242        RefPtr<CSSPrimitiveValue> dash = consumeLengthOrPercent(range, SVGAttributeMode, ValueRange::NonNegative);
    22432243        if (!dash || (consumeCommaIncludingWhitespace(range) && range.atEnd()))
    22442244            return nullptr;
    … …  
    22532253    if (id == CSSValueBaseline || id == CSSValueSub || id == CSSValueSuper)
    22542254        return consumeIdent(range);
    2255     return consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeAll);
     2255    return consumeLengthOrPercent(range, SVGAttributeMode, ValueRange::All);
    22562256}
    22572257
    … …  
    22602260    if (range.peek().id() == CSSValueAuto)
    22612261        return consumeIdent(range);
    2262     return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Forbid);
     2262    return consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative, UnitlessQuirk::Forbid);
    22632263}
    22642264
    … …  
    23892389        return consumeIdent(range);
    23902390
    2391     if (auto parsedValue = consumeLength(range, cssParserMode, ValueRangeAll)) {
     2391    if (auto parsedValue = consumeLength(range, cssParserMode, ValueRange::All)) {
    23922392        if (!parsedValue->isNegative().valueOr(false))
    23932393            return parsedValue;
    … …  
    24622462static RefPtr<CSSValue> consumeBorderRadiusCorner(CSSParserTokenRange& range, CSSParserMode cssParserMode)
    24632463{
    2464     RefPtr<CSSPrimitiveValue> parsedValue1 = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
     2464    RefPtr<CSSPrimitiveValue> parsedValue1 = consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative);
    24652465    if (!parsedValue1)
    24662466        return nullptr;
    2467     RefPtr<CSSPrimitiveValue> parsedValue2 = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
     2467    RefPtr<CSSPrimitiveValue> parsedValue2 = consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative);
    24682468    if (!parsedValue2)
    24692469        parsedValue2 = parsedValue1;
    … …  
    24752475    if (auto value = consumeIdent<CSSValueAuto>(range))
    24762476        return value;
    2477     return consumeLength(range, cssParserMode, ValueRangeAll);
     2477    return consumeLength(range, cssParserMode, ValueRange::All);
    24782478}
    24792479
    … …  
    24822482    if (auto value = consumeIdent<CSSValueAuto, CSSValueFromFont>(range))
    24832483        return value;
    2484     return consumeLength(range, cssParserMode, ValueRangeAll);
     2484    return consumeLength(range, cssParserMode, ValueRange::All);
    24852485}
    24862486
    … …  
    24892489    RefPtr<CSSPrimitiveValue> parsedValue = consumeIdentRange(range, CSSValueBaseline, CSSValueWebkitBaselineMiddle);
    24902490    if (!parsedValue)
    2491         parsedValue = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
     2491        parsedValue = consumeLengthOrPercent(range, cssParserMode, ValueRange::All, UnitlessQuirk::Allow);
    24922492    return parsedValue;
    24932493}
    … …  
    24972497    if (identMatches<CSSValueClosestSide, CSSValueFarthestSide>(args.peek().id()))
    24982498        return consumeIdent(args);
    2499     return consumeLengthOrPercent(args, cssParserMode, ValueRangeNonNegative);
     2499    return consumeLengthOrPercent(args, cssParserMode, ValueRange::NonNegative);
    25002500}
    25012501
    … …  
    25492549
    25502550    do {
    2551         RefPtr<CSSPrimitiveValue> xLength = consumeLengthOrPercent(args, context.mode, ValueRangeAll);
     2551        RefPtr<CSSPrimitiveValue> xLength = consumeLengthOrPercent(args, context.mode, ValueRange::All);
    25522552        if (!xLength)
    25532553            return nullptr;
    2554         RefPtr<CSSPrimitiveValue> yLength = consumeLengthOrPercent(args, context.mode, ValueRangeAll);
     2554        RefPtr<CSSPrimitiveValue> yLength = consumeLengthOrPercent(args, context.mode, ValueRange::All);
    25552555        if (!yLength)
    25562556            return nullptr;
    … …  
    25982598    unsigned i = 0;
    25992599    for (; i < 4 && !range.atEnd() && range.peek().type() != DelimiterToken; ++i) {
    2600         horizontalRadii[i] = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
     2600        horizontalRadii[i] = consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative);
    26012601        if (!horizontalRadii[i])
    26022602            return false;
    … …  
    26192619            return false;
    26202620        for (i = 0; i < 4 && !range.atEnd(); ++i) {
    2621             verticalRadii[i] = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
     2621            verticalRadii[i] = consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative);
    26222622            if (!verticalRadii[i])
    26232623                return false;
    … …  
    26342634{
    26352635    RefPtr<CSSBasicShapeInset> shape = CSSBasicShapeInset::create();
    2636     RefPtr<CSSPrimitiveValue> top = consumeLengthOrPercent(args, context.mode, ValueRangeAll);
     2636    RefPtr<CSSPrimitiveValue> top = consumeLengthOrPercent(args, context.mode, ValueRange::All);
    26372637    if (!top)
    26382638        return nullptr;
    2639     RefPtr<CSSPrimitiveValue> right = consumeLengthOrPercent(args, context.mode, ValueRangeAll);
     2639    RefPtr<CSSPrimitiveValue> right = consumeLengthOrPercent(args, context.mode, ValueRange::All);
    26402640    RefPtr<CSSPrimitiveValue> bottom;
    26412641    RefPtr<CSSPrimitiveValue> left;
    26422642    if (right) {
    2643         bottom = consumeLengthOrPercent(args, context.mode, ValueRangeAll);
     2643        bottom = consumeLengthOrPercent(args, context.mode, ValueRange::All);
    26442644        if (bottom)
    2645             left = consumeLengthOrPercent(args, context.mode, ValueRangeAll);
     2645            left = consumeLengthOrPercent(args, context.mode, ValueRange::All);
    26462646    }
    26472647    if (left)
    … …  
    28682868
    28692869    for (size_t index = 0; index < 4; ++index) {
    2870         RefPtr<CSSPrimitiveValue> value = consumePercent(range, ValueRangeNonNegative);
     2870        RefPtr<CSSPrimitiveValue> value = consumePercent(range, ValueRange::NonNegative);
    28712871        if (!value)
    2872             value = consumeNumber(range, ValueRangeNonNegative);
     2872            value = consumeNumber(range, ValueRange::NonNegative);
    28732873        if (!value)
    28742874            break;
    … …  
    29062906    RefPtr<CSSPrimitiveValue> value;
    29072907    for (size_t index = 0; index < 4; ++index) {
    2908         value = consumeNumber(range, ValueRangeNonNegative);
     2908        value = consumeNumber(range, ValueRange::NonNegative);
    29092909        if (!value)
    2910             value = consumeLength(range, HTMLStandardMode, ValueRangeNonNegative);
     2910            value = consumeLength(range, HTMLStandardMode, ValueRange::NonNegative);
    29112911        if (!value)
    29122912            break;
    … …  
    29332933    RefPtr<CSSPrimitiveValue> value;
    29342934    for (size_t index = 0; index < 4; ++index) {
    2935         value = consumeNumber(range, ValueRangeNonNegative);
     2935        value = consumeNumber(range, ValueRange::NonNegative);
    29362936        if (!value)
    2937             value = consumeLengthOrPercent(range, HTMLStandardMode, ValueRangeNonNegative, UnitlessQuirk::Forbid);
     2937            value = consumeLengthOrPercent(range, HTMLStandardMode, ValueRange::NonNegative, UnitlessQuirk::Forbid);
    29382938        if (!value)
    29392939            value = consumeIdent<CSSValueAuto>(range);
    … …  
    30193019        offset = CSSValuePool::singleton().createValue(0, CSSUnitType::CSS_PX);
    30203020    else {
    3021         offset = consumeLengthOrPercent(range, context.mode, ValueRangeAll, UnitlessQuirk::Forbid);
     3021        offset = consumeLengthOrPercent(range, context.mode, ValueRange::All, UnitlessQuirk::Forbid);
    30223022        if (!offset)
    30233023            return nullptr;
    … …  
    30873087    RefPtr<CSSPrimitiveValue> horizontal = consumeIdent<CSSValueAuto>(range);
    30883088    if (!horizontal)
    3089         horizontal = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
     3089        horizontal = consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative, UnitlessQuirk::Allow);
    30903090
    30913091    RefPtr<CSSPrimitiveValue> vertical;
    … …  
    30943094            range.consumeIncludingWhitespace();
    30953095        else
    3096             vertical = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
     3096            vertical = consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative, UnitlessQuirk::Allow);
    30973097    } else if (!vertical && property == CSSPropertyWebkitBackgroundSize) {
    30983098        // Legacy syntax: "-webkit-background-size: 10px" is equivalent to "background-size: 10px 10px".
    … …  
    32503250    CSSParserTokenRange rangeCopy = range;
    32513251    CSSParserTokenRange args = consumeFunction(rangeCopy);
    3252     RefPtr<CSSPrimitiveValue> length = consumeLengthOrPercent(args, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
     3252    RefPtr<CSSPrimitiveValue> length = consumeLengthOrPercent(args, cssParserMode, ValueRange::NonNegative, UnitlessQuirk::Allow);
    32533253    if (!length || !args.atEnd())
    32543254        return nullptr;
    … …  
    34433443        return CSSPrimitiveValue::create(range.consumeIncludingWhitespace().numericValue(), CSSUnitType::CSS_FR);
    34443444    }
    3445     return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
     3445    return consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative, UnitlessQuirk::Allow);
    34463446}
    34473447
    … …  
    36773677        return ident;
    36783678   
    3679     RefPtr<CSSPrimitiveValue> height = consumeNumber(range, ValueRangeNonNegative);
     3679    RefPtr<CSSPrimitiveValue> height = consumeNumber(range, ValueRange::NonNegative);
    36803680    if (!height)
    36813681        return nullptr;
    … …  
    36833683    RefPtr<CSSPrimitiveValue> position;
    36843684    if (!range.atEnd()) {
    3685         position = consumeNumber(range, ValueRangeNonNegative);
     3685        position = consumeNumber(range, ValueRange::NonNegative);
    36863686        if (!position || !range.atEnd())
    36873687            return nullptr;
    … …  
    37833783static RefPtr<CSSValue> consumeWebkitMarqueeIncrement(CSSParserTokenRange& range, CSSParserMode cssParserMode)
    37843784{
    3785     return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
     3785    return consumeLengthOrPercent(range, cssParserMode, ValueRange::All, UnitlessQuirk::Allow);
    37863786}
    37873787
    37883788static RefPtr<CSSValue> consumeWebkitMarqueeRepetition(CSSParserTokenRange& range)
    37893789{
    3790     return consumeNumber(range, ValueRangeNonNegative);
     3790    return consumeNumber(range, ValueRange::NonNegative);
    37913791}
    37923792
    37933793static RefPtr<CSSValue> consumeWebkitMarqueeSpeed(CSSParserTokenRange& range, CSSParserMode cssParserMode)
    37943794{
    3795     return consumeTime(range, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
     3795    return consumeTime(range, cssParserMode, ValueRange::NonNegative, UnitlessQuirk::Allow);
    37963796}
    37973797
    … …  
    38163816        return RefPtr<CSSValue>(WTFMove(autoValue));
    38173817
    3818     auto leftValue = consumeNumber(range, ValueRangeNonNegative);
     3818    auto leftValue = consumeNumber(range, ValueRange::NonNegative);
    38193819    if (!leftValue)
    38203820        return nullptr;
    … …  
    38223822    bool slashSeen = consumeSlashIncludingWhitespace(range);
    38233823
    3824     auto rightValue = consumeNumber(range, ValueRangeNonNegative);
     3824    auto rightValue = consumeNumber(range, ValueRange::NonNegative);
    38253825    if ((rightValue && !slashSeen) || (!rightValue && slashSeen))
    38263826        return nullptr;
    … …  
    40384038    case CSSPropertyWebkitBorderHorizontalSpacing:
    40394039    case CSSPropertyWebkitBorderVerticalSpacing:
    4040         return consumeLength(m_range, m_context.mode, ValueRangeNonNegative);
     4040        return consumeLength(m_range, m_context.mode, ValueRange::NonNegative);
    40414041    case CSSPropertyCounterIncrement:
    40424042    case CSSPropertyCounterReset:
    … …  
    40864086    case CSSPropertyPaddingBottom:
    40874087    case CSSPropertyPaddingLeft:
    4088         return consumeLengthOrPercent(m_range, m_context.mode, ValueRangeNonNegative, UnitlessQuirk::Allow);
     4088        return consumeLengthOrPercent(m_range, m_context.mode, ValueRange::NonNegative, UnitlessQuirk::Allow);
    40894089    case CSSPropertyPaddingInlineStart:
    40904090    case CSSPropertyPaddingInlineEnd:
    40914091    case CSSPropertyPaddingBlockStart:
    40924092    case CSSPropertyPaddingBlockEnd:
    4093         return consumeLengthOrPercent(m_range, m_context.mode, ValueRangeNonNegative, UnitlessQuirk::Forbid);
     4093        return consumeLengthOrPercent(m_range, m_context.mode, ValueRange::NonNegative, UnitlessQuirk::Forbid);
    40944094    case CSSPropertyScrollMarginBottom:
    40954095    case CSSPropertyScrollMarginLeft:
    … …  
    41004100    case CSSPropertyScrollMarginBlockStart:
    41014101    case CSSPropertyScrollMarginBlockEnd:
    4102         return consumeLength(m_range, m_context.mode, ValueRangeAll);
     4102        return consumeLength(m_range, m_context.mode, ValueRange::All);
    41034103    case CSSPropertyScrollPaddingBottom:
    41044104    case CSSPropertyScrollPaddingLeft:
    … …  
    41364136        return consumeLineClamp(m_range);
    41374137    case CSSPropertyWebkitFontSizeDelta:
    4138         return consumeLength(m_range, m_context.mode, ValueRangeAll, UnitlessQuirk::Allow);
     4138        return consumeLength(m_range, m_context.mode, ValueRange::All, UnitlessQuirk::Allow);
    41394139    case CSSPropertyWebkitHyphenateCharacter:
    41404140    case CSSPropertyWebkitLocale:
    … …  
    41714171        return consumeAnimationPropertyList(property, m_range, m_context);
    41724172    case CSSPropertyShapeMargin:
    4173         return consumeLengthOrPercent(m_range, m_context.mode, ValueRangeNonNegative);
     4173        return consumeLengthOrPercent(m_range, m_context.mode, ValueRange::NonNegative);
    41744174    case CSSPropertyShapeImageThreshold:
    4175         return consumeNumber(m_range, ValueRangeAll);
     4175        return consumeNumber(m_range, ValueRange::All);
    41764176    case CSSPropertyWebkitBoxOrdinalGroup:
    41774177    case CSSPropertyOrphans:
    … …  
    42514251        return consumeOutlineColor(m_range, m_context.mode);
    42524252    case CSSPropertyOutlineOffset:
    4253         return consumeLength(m_range, m_context.mode, ValueRangeAll);
     4253        return consumeLength(m_range, m_context.mode, ValueRange::All);
    42544254    case CSSPropertyOutlineWidth:
    42554255        return consumeLineWidth(m_range, m_context.mode, UnitlessQuirk::Forbid);
    … …  
    42654265        return consumePositionY(m_range, m_context.mode);
    42664266    case CSSPropertyTransformOriginZ:
    4267         return consumeLength(m_range, m_context.mode, ValueRangeAll);
     4267        return consumeLength(m_range, m_context.mode, ValueRange::All);
    42684268    case CSSPropertyTranslate:
    42694269        if (!m_context.individualTransformPropertiesEnabled)
    … …  
    42954295    case CSSPropertyFlexGrow:
    42964296    case CSSPropertyFlexShrink:
    4297         return consumeNumber(m_range, ValueRangeNonNegative);
     4297        return consumeNumber(m_range, ValueRange::NonNegative);
    42984298    case CSSPropertyStrokeDasharray:
    42994299        return consumeStrokeDasharray(m_range);
    … …  
    43054305    case CSSPropertyFloodOpacity:
    43064306    case CSSPropertyOpacity:
    4307         if (auto parsedValue = consumeNumber(m_range, ValueRangeAll))
     4307        if (auto parsedValue = consumeNumber(m_range, ValueRange::All))
    43084308            return parsedValue;
    4309         return consumePercent(m_range, ValueRangeAll);
     4309        return consumePercent(m_range, ValueRange::All);
    43104310    case CSSPropertyWebkitBoxFlex:
    4311         return consumeNumber(m_range, ValueRangeAll);
     4311        return consumeNumber(m_range, ValueRange::All);
    43124312    case CSSPropertyBaselineShift:
    43134313        return consumeBaselineShift(m_range);
    … …  
    43154315        return consumeKerning(m_range, m_context.mode);
    43164316    case CSSPropertyStrokeMiterlimit:
    4317         return consumeNumber(m_range, ValueRangeNonNegative);
     4317        return consumeNumber(m_range, ValueRange::NonNegative);
    43184318    case CSSPropertyStrokeWidth:
    43194319    case CSSPropertyStrokeDashoffset:
    … …  
    43224322    case CSSPropertyX:
    43234323    case CSSPropertyY:
    4324         return consumeLengthOrPercent(m_range, SVGAttributeMode, ValueRangeAll, UnitlessQuirk::Forbid);
     4324        return consumeLengthOrPercent(m_range, SVGAttributeMode, ValueRange::All, UnitlessQuirk::Forbid);
    43254325    case CSSPropertyR:
    4326         return consumeLengthOrPercent(m_range, m_context.mode, ValueRangeNonNegative, UnitlessQuirk::Forbid);
     4326        return consumeLengthOrPercent(m_range, m_context.mode, ValueRange::NonNegative, UnitlessQuirk::Forbid);
    43274327    case CSSPropertyRx:
    43284328    case CSSPropertyRy:
    … …  
    50195019bool CSSPropertyParser::consumeBorderSpacing(bool important)
    50205020{
    5021     RefPtr<CSSValue> horizontalSpacing = consumeLength(m_range, m_context.mode, ValueRangeNonNegative, UnitlessQuirk::Allow);
     5021    RefPtr<CSSValue> horizontalSpacing = consumeLength(m_range, m_context.mode, ValueRange::NonNegative, UnitlessQuirk::Allow);
    50225022    if (!horizontalSpacing)
    50235023        return false;
    50245024    RefPtr<CSSValue> verticalSpacing = horizontalSpacing;
    50255025    if (!m_range.atEnd())
    5026         verticalSpacing = consumeLength(m_range, m_context.mode, ValueRangeNonNegative, UnitlessQuirk::Allow);
     5026        verticalSpacing = consumeLength(m_range, m_context.mode, ValueRange::NonNegative, UnitlessQuirk::Allow);
    50275027    if (!verticalSpacing || !m_range.atEnd())
    50285028        return false;
    … …  
    51345134                    flexBasis = consumeIdent(m_range);
    51355135                if (!flexBasis)
    5136                     flexBasis = consumeLengthOrPercent(m_range, m_context.mode, ValueRangeNonNegative);
     5136                    flexBasis = consumeLengthOrPercent(m_range, m_context.mode, ValueRange::NonNegative);
    51375137                if (index == 2 && !m_range.atEnd())
    51385138                    return false;

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

    r276253 r276550  
    8686}
    8787
    88 static Optional<double> consumeNumberOrPercentDividedBy100Raw(CSSParserTokenRange& range, ValueRange valueRange = ValueRangeAll)
     88static Optional<double> consumeNumberOrPercentDividedBy100Raw(CSSParserTokenRange& range, ValueRange valueRange = ValueRange::All)
    8989{
    9090    if (auto percent = consumePercentRaw(range, valueRange))
    … …  
    9898class CalcParser {
    9999public:
    100     explicit CalcParser(CSSParserTokenRange& range, CalculationCategory destinationCategory, ValueRange valueRange = ValueRangeAll, CSSValuePool& cssValuePool = CSSValuePool::singleton())
     100    explicit CalcParser(CSSParserTokenRange& range, CalculationCategory destinationCategory, ValueRange valueRange = ValueRange::All, CSSValuePool& cssValuePool = CSSValuePool::singleton())
    101101        : m_sourceRange(range)
    102102        , m_range(range)
    … …  
    254254    const CSSParserToken& token = range.peek();
    255255    if (token.type() == NumberToken) {
    256         if (valueRange == ValueRangeNonNegative && token.numericValue() < 0)
     256        if (valueRange == ValueRange::NonNegative && token.numericValue() < 0)
    257257            return WTF::nullopt;
    258258        return range.consumeIncludingWhitespace().numericValue();
    … …  
    307307
    308308    // "[For calc()], the used value resulting from an expression must be clamped to the range allowed in the target context."
    309     CalcParser calcParser(range, CalculationCategory::Number, ValueRangeAll);
     309    CalcParser calcParser(range, CalculationCategory::Number, ValueRange::All);
    310310    if (auto result = calcParser.consumeNumberRaw(); result
    311311#if !ENABLE(VARIATION_FONTS)
    … …  
    373373            return WTF::nullopt;
    374374        }
    375         if ((valueRange == ValueRangeNonNegative && token.numericValue() < 0) || std::isinf(token.numericValue()))
     375        if ((valueRange == ValueRange::NonNegative && token.numericValue() < 0) || std::isinf(token.numericValue()))
    376376            return WTF::nullopt;
    377377        return { { token.unitType(), range.consumeIncludingWhitespace().numericValue() } };
    … …  
    379379    if (token.type() == NumberToken) {
    380380        if (!shouldAcceptUnitlessValue(token.numericValue(), cssParserMode, unitless, UnitlessZeroQuirk::Allow)
    381             || (valueRange == ValueRangeNonNegative && token.numericValue() < 0))
     381            || (valueRange == ValueRange::NonNegative && token.numericValue() < 0))
    382382            return WTF::nullopt;
    383383        if (std::isinf(token.numericValue()))
    … …  
    412412    const CSSParserToken& token = range.peek();
    413413    if (token.type() == PercentageToken) {
    414         if (std::isinf(token.numericValue()) || (valueRange == ValueRangeNonNegative && token.numericValue() < 0))
     414        if (std::isinf(token.numericValue()) || (valueRange == ValueRange::NonNegative && token.numericValue() < 0))
    415415            return WTF::nullopt;
    416416        return range.consumeIncludingWhitespace().numericValue();
    … …  
    530530        return WTF::nullopt;
    531531
    532     CalcParser calcParser(range, CalculationCategory::Angle, ValueRangeAll);
     532    CalcParser calcParser(range, CalculationCategory::Angle, ValueRange::All);
    533533    return calcParser.consumeAngleRaw();
    534534}
    … …  
    543543    const CSSParserToken& token = range.peek();
    544544    if (token.type() == FunctionToken) {
    545         CalcParser calcParser(range, CalculationCategory::Angle, ValueRangeAll, cssValuePool);
     545        CalcParser calcParser(range, CalculationCategory::Angle, ValueRange::All, cssValuePool);
    546546        if (const CSSCalcValue* calculation = calcParser.value()) {
    547547            if (calculation->category() == CalculationCategory::Angle)
    … …  
    602602        unit = CSSUnitType::CSS_MS;
    603603    if (token.type() == DimensionToken || acceptUnitless) {
    604         if (valueRange == ValueRangeNonNegative && token.numericValue() < 0)
     604        if (valueRange == ValueRange::NonNegative && token.numericValue() < 0)
    605605            return nullptr;
    606606        if (unit == CSSUnitType::CSS_MS || unit == CSSUnitType::CSS_S)
    … …  
    19711971    if (range.peek().type() == IdentToken)
    19721972        return consumeIdent<CSSValueLeft, CSSValueTop, CSSValueBottom, CSSValueRight, CSSValueCenter>(range);
    1973     return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, unitless);
     1973    return consumeLengthOrPercent(range, cssParserMode, ValueRange::All, unitless);
    19741974}
    19751975
    … …  
    21832183        return nullptr;
    21842184    }
    2185     RefPtr<CSSPrimitiveValue> result = consumePercent(args, ValueRangeAll);
     2185    RefPtr<CSSPrimitiveValue> result = consumePercent(args, ValueRange::All);
    21862186    if (!result)
    2187         result = consumeNumber(args, ValueRangeAll);
     2187        result = consumeNumber(args, ValueRange::All);
    21882188    return result;
    21892189}
    … …  
    22492249    // For radial gradients only, we now expect a numeric radius.
    22502250    if (isDeprecatedRadialGradient) {
    2251         auto radius = consumeNumber(args, ValueRangeNonNegative);
     2251        auto radius = consumeNumber(args, ValueRange::NonNegative);
    22522252        if (!radius || !consumeCommaIncludingWhitespace(args))
    22532253            return nullptr;
    … …  
    22682268        if (!consumeCommaIncludingWhitespace(args))
    22692269            return nullptr;
    2270         auto radius = consumeNumber(args, ValueRangeNonNegative);
     2270        auto radius = consumeNumber(args, ValueRange::NonNegative);
    22712271        if (!radius)
    22722272            return nullptr;
    … …  
    22912291    auto consumeStopPosition = [&] {
    22922292        return gradient.gradientType() == CSSConicGradient
    2293             ? consumeAngleOrPercent(range, context.mode, ValueRangeAll, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Allow)
    2294             : consumeLengthOrPercent(range, context.mode, ValueRangeAll);
     2293            ? consumeAngleOrPercent(range, context.mode, ValueRange::All, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Allow)
     2294            : consumeLengthOrPercent(range, context.mode, ValueRange::All);
    22952295    };
    22962296
    … …  
    23442344    // Or, two lengths or percentages
    23452345    if (!shape && !sizeKeyword) {
    2346         auto horizontalSize = consumeLengthOrPercent(args, context.mode, ValueRangeNonNegative);
     2346        auto horizontalSize = consumeLengthOrPercent(args, context.mode, ValueRange::NonNegative);
    23472347        RefPtr<CSSPrimitiveValue> verticalSize;
    23482348        if (horizontalSize) {
    2349             verticalSize = consumeLengthOrPercent(args, context.mode, ValueRangeNonNegative);
     2349            verticalSize = consumeLengthOrPercent(args, context.mode, ValueRange::NonNegative);
    23502350            if (!verticalSize)
    23512351                return nullptr;
    … …  
    24012401            }
    24022402        } else {
    2403             auto center = consumeLengthOrPercent(args, context.mode, ValueRangeNonNegative);
     2403            auto center = consumeLengthOrPercent(args, context.mode, ValueRange::NonNegative);
    24042404            if (!center)
    24052405                break;
    … …  
    24072407                return nullptr;
    24082408            horizontalSize = center;
    2409             center = consumeLengthOrPercent(args, context.mode, ValueRangeNonNegative);
     2409            center = consumeLengthOrPercent(args, context.mode, ValueRange::NonNegative);
    24102410            if (center) {
    24112411                verticalSize = center;
    … …  
    28022802            parsedValue = consumeAngle(args, context.mode, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Allow);
    28032803        else if (filterType == CSSValueBlur)
    2804             parsedValue = consumeLength(args, HTMLStandardMode, ValueRangeNonNegative);
     2804            parsedValue = consumeLength(args, HTMLStandardMode, ValueRange::NonNegative);
    28052805        else {
    2806             parsedValue = consumePercent(args, ValueRangeNonNegative);
     2806            parsedValue = consumePercent(args, ValueRange::NonNegative);
    28072807            if (!parsedValue)
    2808                 parsedValue = consumeNumber(args, ValueRangeNonNegative);
     2808                parsedValue = consumeNumber(args, ValueRange::NonNegative);
    28092809            if (parsedValue && !allowsValuesGreaterThanOne(filterType)) {
    28102810                bool isPercentage = downcast<CSSPrimitiveValue>(*parsedValue).isPercentage();
    … …  
    28802880            return nullptr;
    28812881        }
    2882         horizontalOffset = consumeLength(range, context.mode, ValueRangeAll);
     2882        horizontalOffset = consumeLength(range, context.mode, ValueRange::All);
    28832883        if (!horizontalOffset)
    28842884            return nullptr;
    2885         verticalOffset = consumeLength(range, context.mode, ValueRangeAll);
     2885        verticalOffset = consumeLength(range, context.mode, ValueRange::All);
    28862886        if (!verticalOffset)
    28872887            return nullptr;
    … …  
    28902890        // The explicit check for calc() is unfortunate. This is ensuring that we only fail parsing if there is a length, but it fails the range check.
    28912891        if (token.type() == DimensionToken || token.type() == NumberToken || (token.type() == FunctionToken && CSSCalcValue::isCalcFunction(token.functionId()))) {
    2892             blurRadius = consumeLength(range, context.mode, ValueRangeNonNegative);
     2892            blurRadius = consumeLength(range, context.mode, ValueRange::NonNegative);
    28932893            if (!blurRadius)
    28942894                return nullptr;
    … …  
    28962896
    28972897        if (blurRadius && allowSpread)
    2898             spreadDistance = consumeLength(range, context.mode, ValueRangeAll);
     2898            spreadDistance = consumeLength(range, context.mode, ValueRange::All);
    28992899    }
    29002900   
    … …  
    30803080    }
    30813081
    3082     if (auto result = consumeLengthOrPercentRaw(range, cssParserMode, ValueRangeNonNegative, unitless))
     3082    if (auto result = consumeLengthOrPercentRaw(range, cssParserMode, ValueRange::NonNegative, unitless))
    30833083        return { *result };
    30843084
    … …  
    30943094    }
    30953095
    3096     if (auto number = consumeNumberRaw(range, ValueRangeNonNegative))
     3096    if (auto number = consumeNumberRaw(range, ValueRange::NonNegative))
    30973097        return { *number };
    30983098
    3099     if (auto lengthOrPercent = consumeLengthOrPercentRaw(range, cssParserMode, ValueRangeNonNegative))
     3099    if (auto lengthOrPercent = consumeLengthOrPercentRaw(range, cssParserMode, ValueRange::NonNegative))
    31003100        return { *lengthOrPercent };
    31013101

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

    r276152 r276550  
    7979Optional<unsigned> consumePositiveIntegerRaw(CSSParserTokenRange&);
    8080RefPtr<CSSPrimitiveValue> consumePositiveInteger(CSSParserTokenRange&);
    81 Optional<double> consumeNumberRaw(CSSParserTokenRange&, ValueRange = ValueRangeAll);
     81Optional<double> consumeNumberRaw(CSSParserTokenRange&, ValueRange = ValueRange::All);
    8282RefPtr<CSSPrimitiveValue> consumeNumber(CSSParserTokenRange&, ValueRange);
    8383Optional<double> consumeFontWeightNumberRaw(CSSParserTokenRange&);
    … …  
    8686Optional<LengthRaw> consumeLengthRaw(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk = UnitlessQuirk::Forbid);
    8787RefPtr<CSSPrimitiveValue> consumeLength(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk = UnitlessQuirk::Forbid);
    88 Optional<double> consumePercentRaw(CSSParserTokenRange&, ValueRange = ValueRangeAll);
     88Optional<double> consumePercentRaw(CSSParserTokenRange&, ValueRange = ValueRange::All);
    8989RefPtr<CSSPrimitiveValue> consumePercent(CSSParserTokenRange&, ValueRange);
    9090RefPtr<CSSPrimitiveValue> consumePercentWorkerSafe(CSSParserTokenRange&, ValueRange, CSSValuePool&);

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

    r276384 r276550  
    367367        return result;
    368368#if ENABLE(VARIATION_FONTS)
    369     if (auto percent = CSSPropertyParserHelpers::consumePercentWorkerSafe(range, ValueRangeNonNegative, pool))
     369    if (auto percent = CSSPropertyParserHelpers::consumePercentWorkerSafe(range, ValueRange::NonNegative, pool))
    370370        return fontStretchIsWithinRange(percent->value<float>()) ? percent : nullptr;
    371371#endif
    … …  
    378378    if (auto result = consumeFontStretchKeywordValue(range, pool))
    379379        return result;
    380     auto firstPercent = CSSPropertyParserHelpers::consumePercentWorkerSafe(range, ValueRangeNonNegative, pool);
     380    auto firstPercent = CSSPropertyParserHelpers::consumePercentWorkerSafe(range, ValueRange::NonNegative, pool);
    381381    if (!firstPercent || !fontStretchIsWithinRange(firstPercent->value<float>()))
    382382        return nullptr;
    383383    if (range.atEnd())
    384384        return firstPercent;
    385     auto secondPercent = CSSPropertyParserHelpers::consumePercentWorkerSafe(range, ValueRangeNonNegative, pool);
     385    auto secondPercent = CSSPropertyParserHelpers::consumePercentWorkerSafe(range, ValueRange::NonNegative, pool);
    386386    if (!secondPercent || !fontStretchIsWithinRange(secondPercent->value<float>()) || firstPercent->floatValue() > secondPercent->floatValue())
    387387        return nullptr;

  • trunk/Source/WebCore/page/IntersectionObserver.cpp

    r272805 r276550  
    5050        if (margins.size() == 4)
    5151            return Exception { SyntaxError, "Failed to construct 'IntersectionObserver': Extra text found at the end of rootMargin." };
    52         RefPtr<CSSPrimitiveValue> parsedValue = CSSPropertyParserHelpers::consumeLengthOrPercent(tokenRange, HTMLStandardMode, ValueRangeAll);
     52        RefPtr<CSSPrimitiveValue> parsedValue = CSSPropertyParserHelpers::consumeLengthOrPercent(tokenRange, HTMLStandardMode, ValueRange::All);
    5353        if (!parsedValue || parsedValue->isCalculated())
    5454            return Exception { SyntaxError, "Failed to construct 'IntersectionObserver': rootMargin must be specified in pixels or percent." };

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

    r276262 r276550  
    222222inline CalculationValue::CalculationValue(std::unique_ptr<CalcExpressionNode> expression, ValueRange range)
    223223    : m_expression(WTFMove(expression))
    224     , m_shouldClampToNonNegative(range == ValueRangeNonNegative)
     224    , m_shouldClampToNonNegative(range == ValueRange::NonNegative)
    225225{
    226226}

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

    r276141 r276550  
    293293    lengths.uncheckedAppend(makeUnique<CalcExpressionLength>(length));
    294294    auto op = makeUnique<CalcExpressionOperation>(WTFMove(lengths), CalcOperator::Subtract);
    295     return Length(CalculationValue::create(WTFMove(op), ValueRangeAll));
     295    return Length(CalculationValue::create(WTFMove(op), ValueRange::All));
    296296}
    297297
    … …  
    305305
    306306    auto blend = makeUnique<CalcExpressionBlendLength>(from, to, context.progress);
    307     return Length(CalculationValue::create(WTFMove(blend), ValueRangeAll));
     307    return Length(CalculationValue::create(WTFMove(blend), ValueRange::All));
    308308}
    309309
    … …  
    340340{
    341341    auto blended = blend(from, to, context);
    342     if (valueRange == ValueRangeNonNegative && blended.isNegative())
     342    if (valueRange == ValueRange::NonNegative && blended.isNegative())
    343343        return { 0, from.isZero () ? to.type() : from.type() };
    344344    return blended;

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

    r276141 r276550  
    4545};
    4646
    47 enum ValueRange {
    48     ValueRangeAll,
    49     ValueRangeNonNegative
     47enum class ValueRange : uint8_t {
     48    All,
     49    NonNegative
    5050};
    5151

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

    r276205 r276550  
    352352    lengths.uncheckedAppend(makeUnique<CalcExpressionLength>(length));
    353353    auto op = makeUnique<CalcExpressionOperation>(WTFMove(lengths), CalcOperator::Subtract);
    354     return Length(CalculationValue::create(WTFMove(op), ValueRangeAll));
     354    return Length(CalculationValue::create(WTFMove(op), ValueRange::All));
    355355}
    356356

  • trunk/Tools/ChangeLog

    r276540 r276550  
     12021-04-24  Tyler Wilcock  <twilco.o@protonmail.com>
     2
     3        Refactor ValueRange from enum to enum class
     4        https://bugs.webkit.org/show_bug.cgi?id=224981
     5
     6        Reviewed by Sam Weinig.
     7
     8        ValueRange has been refactored from enum to enum class : uint8_t to
     9        make it smaller and harder to misuse.
     10
     11        * TestWebKitAPI/Tests/WebCore/CalculationValue.cpp:
     12        (TestWebKitAPI::createTestValue):
     13        Refactor ValueRangeAll and ValueRangeNonNegative to ValueRange::All
     14        and ValueRange::NonNegative.
     15
    1162021-04-23  Aakash Jain  <aakash_jain@apple.com>
    217

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

    r248846 r276550  
    5555{
    5656    auto node = makeUnique<CalculationDeletionTestNode>();
    57     return WebCore::CalculationValue::create(WTFMove(node), WebCore::ValueRangeAll);
     57    return WebCore::CalculationValue::create(WTFMove(node), WebCore::ValueRange::All);
    5858}
    5959
Note: See TracChangeset for help on using the changeset viewer.