Changeset 282144 in webkit


Ignore:
Timestamp:
Sep 8, 2021 8:34:37 AM (11 months ago)
Author:
Simon Fraser
Message:

Support percentages in the scale() transform functions, and the scale property
​https://bugs.webkit.org/show_bug.cgi?id=202501

Reviewed by Sam Weinig.
LayoutTests/imported/w3c:

  • web-platform-tests/css/css-transforms/parsing/scale-parsing-valid-expected.txt:
  • web-platform-tests/css/css-transforms/parsing/transform-valid-expected.txt:

Source/WebCore:

Support percentage values in the scale*() functions in the transform property, and
on the scale property. These value are converted by numbers by dividing by 100
at parse time, as we do for alpha values in colors. We have to keep calc() intact,
so % calcs need to be divided by 100 at use time.

Test: transforms/2d/scale-percent.html

  • css/CSSPrimitiveValue.cpp:

(WebCore::CSSPrimitiveValue::doubleValueDividingBy100IfPercentage const):

  • css/CSSPrimitiveValue.h:
  • css/TransformFunctions.cpp:

(WebCore::transformsForValue):
(WebCore::scaleForValue):

  • css/parser/CSSPropertyParser.cpp:

(WebCore::consumeNumbersOrPercents):
(WebCore::consumeTransformValue):
(WebCore::consumeScale):

  • css/parser/CSSPropertyParserHelpers.cpp:

(WebCore::CSSPropertyParserHelpers::consumeNumberRawOrPercentRaw):
(WebCore::CSSPropertyParserHelpers::consumeNumberRawOrPercentRawAllowingSymbolTableIdent):
(WebCore::CSSPropertyParserHelpers::consumeNumberOrPercent):

  • css/parser/CSSPropertyParserHelpers.h:

LayoutTests:

Ref test for scales with %.

  • transforms/2d/scale-percent-expected.html: Added.
  • transforms/2d/scale-percent.html: Added.
Location:
trunk
Files:
2 added
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r282143 r282144  
     12021-09-08  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Support percentages in the scale() transform functions, and the scale property
     4        https://bugs.webkit.org/show_bug.cgi?id=202501
     5
     6        Reviewed by Sam Weinig.
     7       
     8        Ref test for scales with %.
     9
     10        * transforms/2d/scale-percent-expected.html: Added.
     11        * transforms/2d/scale-percent.html: Added.
     12
    1132021-09-08  Simon Fraser  <simon.fraser@apple.com>
    214

  • trunk/LayoutTests/imported/w3c/ChangeLog

    r282138 r282144  
     12021-09-08  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Support percentages in the scale() transform functions, and the scale property
     4        https://bugs.webkit.org/show_bug.cgi?id=202501
     5
     6        Reviewed by Sam Weinig.
     7
     8        * web-platform-tests/css/css-transforms/parsing/scale-parsing-valid-expected.txt:
     9        * web-platform-tests/css/css-transforms/parsing/transform-valid-expected.txt:
     10
    1112021-09-08  Martin Robinson  <mrobinson@webkit.org>
    212

  • trunk/LayoutTests/imported/w3c/web-platform-tests/css/css-transforms/parsing/scale-parsing-valid-expected.txt

    r282089 r282144  
    22PASS e.style['scale'] = "none" should set the property value
    33PASS e.style['scale'] = "1" should set the property value
    4 FAIL e.style['scale'] = "1%" should set the property value assert_not_equals: property should be set got disallowed value ""
     4PASS e.style['scale'] = "1%" should set the property value
    55PASS e.style['scale'] = "100" should set the property value
    6 FAIL e.style['scale'] = "100%" should set the property value assert_not_equals: property should be set got disallowed value ""
     6PASS e.style['scale'] = "100%" should set the property value
    77PASS e.style['scale'] = "100 100" should set the property value
    8 FAIL e.style['scale'] = "100% 100%" should set the property value assert_not_equals: property should be set got disallowed value ""
     8PASS e.style['scale'] = "100% 100%" should set the property value
    99PASS e.style['scale'] = "100 100 1" should set the property value
    10 FAIL e.style['scale'] = "100% 100% 1" should set the property value assert_not_equals: property should be set got disallowed value ""
     10PASS e.style['scale'] = "100% 100% 1" should set the property value
    1111PASS e.style['scale'] = "-100" should set the property value
    12 FAIL e.style['scale'] = "-100%" should set the property value assert_not_equals: property should be set got disallowed value ""
     12PASS e.style['scale'] = "-100%" should set the property value
    1313PASS e.style['scale'] = "-100 -100" should set the property value
    14 FAIL e.style['scale'] = "-100% -100%" should set the property value assert_not_equals: property should be set got disallowed value ""
     14PASS e.style['scale'] = "-100% -100%" should set the property value
    1515PASS e.style['scale'] = "-100 -100 1" should set the property value
    16 FAIL e.style['scale'] = "-100% -100% 1" should set the property value assert_not_equals: property should be set got disallowed value ""
     16PASS e.style['scale'] = "-100% -100% 1" should set the property value
    1717PASS e.style['scale'] = "100 200" should set the property value
    18 FAIL e.style['scale'] = "100% 200%" should set the property value assert_not_equals: property should be set got disallowed value ""
     18PASS e.style['scale'] = "100% 200%" should set the property value
    1919PASS e.style['scale'] = "100 200 1" should set the property value
    20 FAIL e.style['scale'] = "100% 200% 1" should set the property value assert_not_equals: property should be set got disallowed value ""
     20PASS e.style['scale'] = "100% 200% 1" should set the property value
    2121PASS e.style['scale'] = "100 200 300" should set the property value
    2222PASS e.style['scale'] = "100 100 2" should set the property value
    23 FAIL e.style['scale'] = "100% 200% 300%" should set the property value assert_not_equals: property should be set got disallowed value ""
     23PASS e.style['scale'] = "100% 200% 300%" should set the property value
    2424

  • trunk/LayoutTests/imported/w3c/web-platform-tests/css/css-transforms/parsing/transform-valid-expected.txt

    r282089 r282144  
    1212PASS e.style['transform'] = "scale(-2)" should set the property value
    1313PASS e.style['transform'] = "scale(-5, -6)" should set the property value
    14 FAIL e.style['transform'] = "scale(250%)" should set the property value assert_not_equals: property should be set got disallowed value ""
    15 FAIL e.style['transform'] = "scale(325%, 475%)" should set the property value assert_not_equals: property should be set got disallowed value ""
    16 FAIL e.style['transform'] = "scale(1, 200%)" should set the property value assert_not_equals: property should be set got disallowed value ""
    17 FAIL e.style['transform'] = "scale(-250%)" should set the property value assert_not_equals: property should be set got disallowed value ""
    18 FAIL e.style['transform'] = "scale(-500%, -620%)" should set the property value assert_not_equals: property should be set got disallowed value ""
     14PASS e.style['transform'] = "scale(250%)" should set the property value
     15PASS e.style['transform'] = "scale(325%, 475%)" should set the property value
     16PASS e.style['transform'] = "scale(1, 200%)" should set the property value
     17PASS e.style['transform'] = "scale(-250%)" should set the property value
     18PASS e.style['transform'] = "scale(-500%, -620%)" should set the property value
    1919PASS e.style['transform'] = "scaleX(7)" should set the property value
    20 FAIL e.style['transform'] = "scaleX(720%)" should set the property value assert_not_equals: property should be set got disallowed value ""
     20PASS e.style['transform'] = "scaleX(720%)" should set the property value
    2121PASS e.style['transform'] = "scaleY(-8)" should set the property value
    22 FAIL e.style['transform'] = "scaleY(-85%)" should set the property value assert_not_equals: property should be set got disallowed value ""
     22PASS e.style['transform'] = "scaleY(-85%)" should set the property value
    2323PASS e.style['transform'] = "scaleZ(4)" should set the property value
    24 FAIL e.style['transform'] = "scaleZ(25%)" should set the property value assert_not_equals: property should be set got disallowed value ""
     24PASS e.style['transform'] = "scaleZ(25%)" should set the property value
    2525PASS e.style['transform'] = "scale3d(0.5, 2.5, 3)" should set the property value
    26 FAIL e.style['transform'] = "scale3d(50%, 250%, 300%)" should set the property value assert_not_equals: property should be set got disallowed value ""
     26PASS e.style['transform'] = "scale3d(50%, 250%, 300%)" should set the property value
    2727PASS e.style['transform'] = "scale3d(-0.5, 2.5, -3)" should set the property value
    28 FAIL e.style['transform'] = "scale3d(-50%, 250%, -300%)" should set the property value assert_not_equals: property should be set got disallowed value ""
    29 FAIL e.style['transform'] = "scale3d(1, 200%, 3)" should set the property value assert_not_equals: property should be set got disallowed value ""
     28PASS e.style['transform'] = "scale3d(-50%, 250%, -300%)" should set the property value
     29PASS e.style['transform'] = "scale3d(1, 200%, 3)" should set the property value
    3030PASS e.style['transform'] = "rotate(0)" should set the property value
    3131PASS e.style['transform'] = "rotate(90deg)" should set the property value

  • trunk/Source/WebCore/ChangeLog

    r282143 r282144  
     12021-09-08  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Support percentages in the scale() transform functions, and the scale property
     4        https://bugs.webkit.org/show_bug.cgi?id=202501
     5
     6        Reviewed by Sam Weinig.
     7
     8        Support percentage values in the scale*() functions in the transform property, and
     9        on the scale property. These value are converted by numbers by dividing by 100
     10        at parse time, as we do for alpha values in colors. We have to keep calc() intact,
     11        so % calcs need to be divided by 100 at use time.
     12
     13        Test: transforms/2d/scale-percent.html
     14
     15        * css/CSSPrimitiveValue.cpp:
     16        (WebCore::CSSPrimitiveValue::doubleValueDividingBy100IfPercentage const):
     17        * css/CSSPrimitiveValue.h:
     18        * css/TransformFunctions.cpp:
     19        (WebCore::transformsForValue):
     20        (WebCore::scaleForValue):
     21        * css/parser/CSSPropertyParser.cpp:
     22        (WebCore::consumeNumbersOrPercents):
     23        (WebCore::consumeTransformValue):
     24        (WebCore::consumeScale):
     25        * css/parser/CSSPropertyParserHelpers.cpp:
     26        (WebCore::CSSPropertyParserHelpers::consumeNumberRawOrPercentRaw):
     27        (WebCore::CSSPropertyParserHelpers::consumeNumberRawOrPercentRawAllowingSymbolTableIdent):
     28        (WebCore::CSSPropertyParserHelpers::consumeNumberOrPercent):
     29        * css/parser/CSSPropertyParserHelpers.h:
     30
    1312021-09-08  Simon Fraser  <simon.fraser@apple.com>
    232

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

    r278648 r282144  
    829829{
    830830    return primitiveUnitType() != CSSUnitType::CSS_CALC ? m_value.num : m_value.calc->doubleValue();
     831}
     832
     833double CSSPrimitiveValue::doubleValueDividingBy100IfPercentage() const
     834{
     835    switch (primitiveUnitType()) {
     836    case CSSUnitType::CSS_CALC:
     837        return m_value.calc->primitiveType() == CSSUnitType::CSS_PERCENTAGE ? m_value.calc->doubleValue() / 100.0 : m_value.calc->doubleValue();
     838   
     839    case CSSUnitType::CSS_PERCENTAGE:
     840        return m_value.num / 100.0;
     841       
     842    default:
     843        return m_value.num;
     844    }
    831845}
    832846

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

    r281785 r282144  
    150150    // It's usually wrong to call this; it can trigger type conversion in calc without sufficient context to resolve relative length units.
    151151    double doubleValue() const;
     152   
     153    double doubleValueDividingBy100IfPercentage() const;
    152154
    153155    // These return nullopt for calc, for which range checking is not done at parse time: <https://www.w3.org/TR/css3-values/#calc-range>.

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

    r276554 r282144  
    137137            double sy = 1.0;
    138138            if (transformValue.name() == CSSValueScaleY)
    139                 sy = firstValue.doubleValue();
    140             else {
    141                 sx = firstValue.doubleValue();
     139                sy = firstValue.doubleValueDividingBy100IfPercentage();
     140            else {
     141                sx = firstValue.doubleValueDividingBy100IfPercentage();
    142142                if (transformValue.name() != CSSValueScaleX) {
    143143                    if (transformValue.length() > 1) {
    144144                        auto& secondValue = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(1));
    145                         sy = secondValue.doubleValue();
     145                        sy = secondValue.doubleValueDividingBy100IfPercentage();
    146146                    } else
    147147                        sy = sx;
    … …  
    157157            double sz = 1.0;
    158158            if (transformValue.name() == CSSValueScaleZ)
    159                 sz = firstValue.doubleValue();
     159                sz = firstValue.doubleValueDividingBy100IfPercentage();
    160160            else if (transformValue.name() == CSSValueScaleY)
    161                 sy = firstValue.doubleValue();
    162             else {
    163                 sx = firstValue.doubleValue();
     161                sy = firstValue.doubleValueDividingBy100IfPercentage();
     162            else {
     163                sx = firstValue.doubleValueDividingBy100IfPercentage();
    164164                if (transformValue.name() != CSSValueScaleX) {
    165165                    if (transformValue.length() > 2) {
    166166                        auto& thirdValue = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(2));
    167                         sz = thirdValue.doubleValue();
     167                        sz = thirdValue.doubleValueDividingBy100IfPercentage();
    168168                    }
    169169                    if (transformValue.length() > 1) {
    170170                        auto& secondValue = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(1));
    171                         sy = secondValue.doubleValue();
     171                        sy = secondValue.doubleValueDividingBy100IfPercentage();
    172172                    } else
    173173                        sy = sx;
    … …  
    397397            return nullptr;
    398398        if (!i) {
    399             sx = downcast<CSSPrimitiveValue>(*valueItem).doubleValue();
     399            sx = downcast<CSSPrimitiveValue>(*valueItem).doubleValueDividingBy100IfPercentage();
    400400            sy = sx;
    401401        } else if (i == 1)
    402             sy = downcast<CSSPrimitiveValue>(*valueItem).doubleValue();
     402            sy = downcast<CSSPrimitiveValue>(*valueItem).doubleValueDividingBy100IfPercentage();
    403403        else if (i == 2) {
    404404            type = TransformOperation::SCALE_3D;
    405             sz = downcast<CSSPrimitiveValue>(*valueItem).doubleValue();
     405            sz = downcast<CSSPrimitiveValue>(*valueItem).doubleValueDividingBy100IfPercentage();
    406406        }
    407407    }

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

    r282143 r282144  
    17941794}
    17951795
     1796static bool consumeNumbersOrPercents(CSSParserTokenRange& args, RefPtr<CSSFunctionValue>& transformValue, unsigned numberOfArguments)
     1797{
     1798    auto parseNumberAndAppend = [&] {
     1799        auto parsedValue = consumeNumberOrPercent(args, ValueRange::All);
     1800        if (!parsedValue)
     1801            return false;
     1802
     1803        transformValue->append(parsedValue.releaseNonNull());
     1804        --numberOfArguments;
     1805        return true;
     1806    };
     1807
     1808    if (!parseNumberAndAppend())
     1809        return false;
     1810
     1811    while (numberOfArguments) {
     1812        if (!consumeCommaIncludingWhitespace(args))
     1813            return false;
     1814
     1815        if (!parseNumberAndAppend())
     1816            return false;
     1817    }
     1818
     1819    return true;
     1820}
     1821
    17961822static bool consumePerspective(CSSParserTokenRange& args, CSSParserMode cssParserMode, RefPtr<CSSFunctionValue>& transformValue)
    17971823{
    … …  
    18411867    case CSSValueScaleZ:
    18421868    case CSSValueScale:
    1843         parsedValue = consumeNumber(args, ValueRange::All);
     1869        parsedValue = consumeNumberOrPercent(args, ValueRange::All);
    18441870        if (!parsedValue)
    18451871            return nullptr;
    18461872        if (functionId == CSSValueScale && consumeCommaIncludingWhitespace(args)) {
    18471873            transformValue->append(*parsedValue);
    1848             parsedValue = consumeNumber(args, ValueRange::All);
     1874            parsedValue = consumeNumberOrPercent(args, ValueRange::All);
    18491875            if (!parsedValue)
    18501876                return nullptr;
    … …  
    18771903        break;
    18781904    case CSSValueScale3d:
    1879         if (!consumeNumbers(args, transformValue, 3))
     1905        if (!consumeNumbersOrPercents(args, transformValue, 3))
    18801906            return nullptr;
    18811907        break;
    … …  
    19842010    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
    19852011
    1986     RefPtr<CSSValue> x = consumeNumber(range, ValueRange::All);
     2012    RefPtr<CSSValue> x = consumeNumberOrPercent(range, ValueRange::All);
    19872013    if (!x)
    19882014        return list;
    … …  
    19902016    range.consumeWhitespace();
    19912017
    1992     RefPtr<CSSValue> y = consumeNumber(range, ValueRange::All);
     2018    RefPtr<CSSValue> y = consumeNumberOrPercent(range, ValueRange::All);
    19932019    if (!y)
    19942020        return list;
    19952021
    19962022    // If the x and y values are the same, the y value is not needed.
    1997     if (downcast<CSSPrimitiveValue>(*x).floatValue() != downcast<CSSPrimitiveValue>(*y).floatValue())
     2023    if (downcast<CSSPrimitiveValue>(*x).doubleValue() != downcast<CSSPrimitiveValue>(*y).doubleValue())
    19982024        list->append(*y);
    19992025    range.consumeWhitespace();
    20002026
    2001     RefPtr<CSSValue> z = consumeNumber(range, ValueRange::All);
     2027    RefPtr<CSSValue> z = consumeNumberOrPercent(range, ValueRange::All);
    20022028    if (!z)
    20032029        return list;
    2004     if (downcast<CSSPrimitiveValue>(*z).floatValue() != 1.0) {
     2030    if (downcast<CSSPrimitiveValue>(*z).doubleValue() != 1.0) {
    20052031        // We only need to append the z value if it's set to something other than 1.
    20062032        // In case y was not added yet, because it was equal to x, we must append it

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

    r279498 r282144  
    257257}
    258258
    259 // MARK: Integer (CSSPrimitiveValue - not maintaing calc)
     259// MARK: Integer (CSSPrimitiveValue - not maintaining calc)
    260260
    261261template<typename IntType> static RefPtr<CSSPrimitiveValue> consumeIntegerTypeCSSPrimitiveValueWithCalcWithKnownTokenTypeFunction(CSSParserTokenRange& range, double minimumValue, CSSValuePool& pool)
    … …  
    325325}
    326326
    327 // MARK: Number (CSSPrimitiveValue - maintaing calc)
     327// MARK: Number (CSSPrimitiveValue - maintaining calc)
    328328
    329329static RefPtr<CSSPrimitiveValue> consumeNumberCSSPrimitiveValueWithCalcWithKnownTokenTypeFunction(CSSParserTokenRange& range, const CSSCalcSymbolTable& symbolTable, ValueRange valueRange, CSSValuePool& pool)
    … …  
    401401
    402402
    403 // MARK: Percent (CSSPrimitiveValue - maintaing calc)
     403// MARK: Percent (CSSPrimitiveValue - maintaining calc)
    404404
    405405static RefPtr<CSSPrimitiveValue> consumePercentCSSPrimitiveValueWithCalcWithKnownTokenTypeFunction(CSSParserTokenRange& range, const CSSCalcSymbolTable& symbolTable, ValueRange valueRange, CSSValuePool& pool)
    … …  
    498498}
    499499
    500 // MARK: Length (CSSPrimitiveValue - maintaing calc)
     500// MARK: Length (CSSPrimitiveValue - maintaining calc)
    501501
    502502static RefPtr<CSSPrimitiveValue> consumeLengthCSSPrimitiveValueWithCalcWithKnownTokenTypeFunction(CSSParserTokenRange& range, const CSSCalcSymbolTable& symbolTable, ValueRange valueRange, CSSParserMode, UnitlessQuirk, CSSValuePool& pool)
    … …  
    563563}
    564564
    565 // MARK: Angle (CSSPrimitiveValue - maintaing calc)
     565// MARK: Angle (CSSPrimitiveValue - maintaining calc)
    566566
    567567static RefPtr<CSSPrimitiveValue> consumeAngleCSSPrimitiveValueWithCalcWithKnownTokenTypeFunction(CSSParserTokenRange& range, const CSSCalcSymbolTable& symbolTable, ValueRange valueRange, CSSParserMode, UnitlessQuirk, UnitlessZeroQuirk, CSSValuePool& pool)
    … …  
    592592
    593593
    594 // MARK: Time (CSSPrimitiveValue - maintaing calc)
     594// MARK: Time (CSSPrimitiveValue - maintaining calc)
    595595
    596596static RefPtr<CSSPrimitiveValue> consumeTimeCSSPrimitiveValueWithCalcWithKnownTokenTypeFunction(CSSParserTokenRange& range, const CSSCalcSymbolTable& symbolTable, ValueRange valueRange, CSSParserMode, UnitlessQuirk, CSSValuePool& pool)
    … …  
    11221122
    11231123template<typename NumberTransformer, typename PercentTransformer>
    1124 static auto consumeNumberRawOrPercentRaw(CSSParserTokenRange& range, ValueRange valueRange, NumberTransformer&& numberTranformer, PercentTransformer&& percentTranformer) -> std::optional<decltype(numberTranformer(std::declval<double>()))>
     1124static auto consumeNumberRawOrPercentRaw(CSSParserTokenRange& range, ValueRange valueRange, NumberTransformer&& numberTransformer, PercentTransformer&& percentTransformer) -> std::optional<decltype(numberTransformer(std::declval<double>()))>
    11251125{
    11261126    const auto& token = range.peek();
    … …  
    11291129    case FunctionToken: {
    11301130        if (auto number = consumeNumberRawWithKnownTokenTypeFunction(range, { }, valueRange))
    1131             return numberTranformer(*number);
     1131            return numberTransformer(*number);
    11321132        if (auto percent = consumePercentRawWithKnownTokenTypeFunction(range, { }, valueRange))
    1133             return percentTranformer(*percent);
     1133            return percentTransformer(*percent);
    11341134        break;
    11351135    }
    … …  
    11371137    case PercentageToken:
    11381138        if (auto percent = consumePercentRawWithKnownTokenTypePercentage(range, { }, valueRange))
    1139             return percentTranformer(*percent);
     1139            return percentTransformer(*percent);
    11401140        break;
    11411141
    11421142    case NumberToken:
    11431143        if (auto number = consumeNumberRawWithKnownTokenTypeNumber(range, { }, valueRange))
    1144             return numberTranformer(*number);
     1144            return numberTransformer(*number);
    11451145        break;
    11461146
    … …  
    11601160
    11611161template<typename NumberTransformer, typename PercentTransformer>
    1162 static auto consumeNumberRawOrPercentRawAllowingSymbolTableIdent(CSSParserTokenRange& range, const CSSCalcSymbolTable& symbolTable, ValueRange valueRange, NumberTransformer&& numberTranformer, PercentTransformer&& percentTranformer) -> std::optional<decltype(numberTranformer(std::declval<double>()))>
     1162static auto consumeNumberRawOrPercentRawAllowingSymbolTableIdent(CSSParserTokenRange& range, const CSSCalcSymbolTable& symbolTable, ValueRange valueRange, NumberTransformer&& numberTransformer, PercentTransformer&& percentTransformer) -> std::optional<decltype(numberTransformer(std::declval<double>()))>
    11631163{
    11641164    auto& token = range.peek();
    … …  
    11671167    case FunctionToken: {
    11681168        if (auto number = consumeNumberRawWithKnownTokenTypeFunction(range, symbolTable, valueRange))
    1169             return numberTranformer(*number);
     1169            return numberTransformer(*number);
    11701170        if (auto percent = consumePercentRawWithKnownTokenTypeFunction(range, symbolTable, valueRange))
    1171             return percentTranformer(*percent);
     1171            return percentTransformer(*percent);
    11721172        break;
    11731173    }
    … …  
    11751175    case PercentageToken:
    11761176        if (auto percent = consumePercentRawWithKnownTokenTypePercentage(range, symbolTable, valueRange))
    1177             return percentTranformer(*percent);
     1177            return percentTransformer(*percent);
    11781178        break;
    11791179
    11801180    case NumberToken:
    11811181        if (auto number = consumeNumberRawWithKnownTokenTypeNumber(range, symbolTable, valueRange))
    1182             return numberTranformer(*number);
     1182            return numberTransformer(*number);
    11831183        break;
    11841184
    … …  
    11891189                if (auto validatedValue = validatedPercentRaw(variable->value, valueRange)) {
    11901190                    range.consumeIncludingWhitespace();
    1191                     return percentTranformer(*validatedValue);
     1191                    return percentTransformer(*validatedValue);
    11921192                }
    11931193                break;
    … …  
    11961196                if (auto validatedValue = validatedNumberRaw(variable->value, valueRange)) {
    11971197                    range.consumeIncludingWhitespace();
    1198                     return numberTranformer(*validatedValue);
     1198                    return numberTransformer(*validatedValue);
    11991199                }
    12001200                break;
    … …  
    12161216{
    12171217    return consumeNumberRawOrPercentRawAllowingSymbolTableIdent(range, symbolTable, valueRange, [](double number) { return number; }, [](double percent) { return percent / 100.0; });
     1218}
     1219
     1220RefPtr<CSSPrimitiveValue> consumeNumberOrPercent(CSSParserTokenRange& range, ValueRange valueRange)
     1221{
     1222    auto& token = range.peek();
     1223
     1224    switch (token.type()) {
     1225    case FunctionToken:
     1226        if (auto value = consumeNumberCSSPrimitiveValueWithCalcWithKnownTokenTypeFunction(range, { }, valueRange, CSSValuePool::singleton()))
     1227            return value;
     1228        return consumePercentCSSPrimitiveValueWithCalcWithKnownTokenTypeFunction(range, { }, valueRange, CSSValuePool::singleton());
     1229
     1230    case NumberToken:
     1231    case PercentageToken: {
     1232        auto value = consumeNumberRawOrPercentDividedBy100Raw(range, valueRange);
     1233        if (value)
     1234            return CSSValuePool::singleton().createValue(*value, CSSUnitType::CSS_NUMBER);
     1235        break;
     1236    }
     1237    default:
     1238        break;
     1239    }
     1240
     1241    return nullptr;
    12181242}
    12191243

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

    r278253 r282144  
    8181std::optional<double> consumeNumberRaw(CSSParserTokenRange&, ValueRange = ValueRange::All);
    8282RefPtr<CSSPrimitiveValue> consumeNumber(CSSParserTokenRange&, ValueRange);
     83RefPtr<CSSPrimitiveValue> consumeNumberOrPercent(CSSParserTokenRange&, ValueRange);
    8384std::optional<double> consumeFontWeightNumberRaw(CSSParserTokenRange&);
    8485RefPtr<CSSPrimitiveValue> consumeFontWeightNumber(CSSParserTokenRange&);
Note: See TracChangeset for help on using the changeset viewer.