Modified: trunk/Source/WebCore/css/parser/CSSPropertyParser.cpp (272093 => 272094)
--- trunk/Source/WebCore/css/parser/CSSPropertyParser.cpp 2021-01-30 01:52:34 UTC (rev 272093)
+++ trunk/Source/WebCore/css/parser/CSSPropertyParser.cpp 2021-01-30 02:13:44 UTC (rev 272094)
@@ -520,12 +520,11 @@
if (range.atEnd())
return nullptr;
- double tagValue = 0;
- auto success = consumeNumberRaw(range, tagValue);
- if (!success)
+ auto tagValue = consumeNumberRaw(range);
+ if (!tagValue)
return nullptr;
- return CSSFontVariationValue::create(tag, tagValue);
+ return CSSFontVariationValue::create(tag, *tagValue);
}
static RefPtr<CSSValue> consumeFontVariationSettings(CSSParserTokenRange& range)
@@ -1508,22 +1507,36 @@
CSSParserTokenRange rangeCopy = range;
CSSParserTokenRange args = consumeFunction(rangeCopy);
- double x1, y1, x2, y2;
- if (consumeNumberRaw(args, x1)
- && x1 >= 0 && x1 <= 1
- && consumeCommaIncludingWhitespace(args)
- && consumeNumberRaw(args, y1)
- && consumeCommaIncludingWhitespace(args)
- && consumeNumberRaw(args, x2)
- && x2 >= 0 && x2 <= 1
- && consumeCommaIncludingWhitespace(args)
- && consumeNumberRaw(args, y2)
- && args.atEnd()) {
- range = rangeCopy;
- return CSSCubicBezierTimingFunctionValue::create(x1, y1, x2, y2);
- }
+ auto x1 = consumeNumberRaw(args);
+ if (!x1 || *x1 < 0 || *x1 > 1)
+ return nullptr;
+
+ if (!consumeCommaIncludingWhitespace(args))
+ return nullptr;
- return nullptr;
+ auto y1 = consumeNumberRaw(args);
+ if (!y1)
+ return nullptr;
+
+ if (!consumeCommaIncludingWhitespace(args))
+ return nullptr;
+
+ auto x2 = consumeNumberRaw(args);
+ if (!x2 || *x2 < 0 || *x2 > 1)
+ return nullptr;
+
+ if (!consumeCommaIncludingWhitespace(args))
+ return nullptr;
+
+ auto y2 = consumeNumberRaw(args);
+ if (!y2)
+ return nullptr;
+
+ if (!args.atEnd())
+ return nullptr;
+
+ range = rangeCopy;
+ return CSSCubicBezierTimingFunctionValue::create(*x1, *y1, *x2, *y2);
}
static RefPtr<CSSValue> consumeSpringFunction(CSSParserTokenRange& range)
@@ -1533,23 +1546,23 @@
CSSParserTokenRange args = consumeFunction(rangeCopy);
// Mass must be greater than 0.
- double mass;
- if (!consumeNumberRaw(args, mass) || mass <= 0)
+ auto mass = consumeNumberRaw(args);
+ if (!mass || *mass <= 0)
return nullptr;
// Stiffness must be greater than 0.
- double stiffness;
- if (!consumeNumberRaw(args, stiffness) || stiffness <= 0)
+ auto stiffness = consumeNumberRaw(args);
+ if (!stiffness || *stiffness <= 0)
return nullptr;
// Damping coefficient must be greater than or equal to 0.
- double damping;
- if (!consumeNumberRaw(args, damping) || damping < 0)
+ auto damping = consumeNumberRaw(args);
+ if (!damping || *damping < 0)
return nullptr;
// Initial velocity may have any value.
- double initialVelocity;
- if (!consumeNumberRaw(args, initialVelocity))
+ auto initialVelocity = consumeNumberRaw(args);
+ if (!initialVelocity)
return nullptr;
if (!args.atEnd())
@@ -1557,7 +1570,7 @@
range = rangeCopy;
- return CSSSpringTimingFunctionValue::create(mass, stiffness, damping, initialVelocity);
+ return CSSSpringTimingFunctionValue::create(*mass, *stiffness, *damping, *initialVelocity);
}
static RefPtr<CSSValue> consumeAnimationTimingFunction(CSSParserTokenRange& range, const CSSParserContext& context)
@@ -1878,16 +1891,15 @@
static bool consumePerspective(CSSParserTokenRange& args, CSSParserMode cssParserMode, RefPtr<CSSFunctionValue>& transformValue)
{
- RefPtr<CSSPrimitiveValue> parsedValue = consumeLength(args, cssParserMode, ValueRangeNonNegative);
- if (!parsedValue) {
- double perspective;
- if (!consumeNumberRaw(args, perspective) || perspective < 0)
- return false;
- parsedValue = CSSPrimitiveValue::create(perspective, CSSUnitType::CSS_PX);
+ if (auto parsedValue = consumeLength(args, cssParserMode, ValueRangeNonNegative)) {
+ transformValue->append(parsedValue.releaseNonNull());
+ return true;
}
- if (!parsedValue)
+
+ auto perspective = consumeNumberRaw(args);
+ if (!perspective || *perspective < 0)
return false;
- transformValue->append(parsedValue.releaseNonNull());
+ transformValue->append(CSSPrimitiveValue::create(*perspective, CSSUnitType::CSS_PX));
return true;
}
@@ -2363,14 +2375,14 @@
{
RefPtr<CSSValueList> list;
while (RefPtr<CSSValue> image = consumeImage(range, context, { AllowedImageType::URLFunction, AllowedImageType::ImageSet })) {
- double num;
IntPoint hotSpot(-1, -1);
bool hotSpotSpecified = false;
- if (consumeNumberRaw(range, num)) {
- hotSpot.setX(int(num));
- if (!consumeNumberRaw(range, num))
+ if (auto x = consumeNumberRaw(range)) {
+ hotSpot.setX(static_cast<int>(*x));
+ auto y = consumeNumberRaw(range);
+ if (!y)
return nullptr;
- hotSpot.setY(int(num));
+ hotSpot.setY(static_cast<int>(*y));
hotSpotSpecified = true;
}
@@ -2484,22 +2496,18 @@
{
if (range.peek().id() == CSSValueNone)
return consumeIdent(range);
- RefPtr<CSSPrimitiveValue> parsedValue = consumeLength(range, cssParserMode, ValueRangeAll);
- if (!parsedValue) {
- // FIXME: Make this quirk only apply to the webkit prefixed version of the property.
- double perspective;
- if (!consumeNumberRaw(range, perspective))
- return nullptr;
- parsedValue = CSSPrimitiveValue::create(perspective, CSSUnitType::CSS_PX);
+
+ if (auto parsedValue = consumeLength(range, cssParserMode, ValueRangeAll)) {
+ if (parsedValue->isPositive().valueOr(true))
+ return parsedValue;
+ return nullptr;
}
- if (!parsedValue)
+ // FIXME: Make this quirk only apply to the webkit prefixed version of the property.
+ auto perspective = consumeNumberRaw(range);
+ if (!perspective || *perspective < 0)
return nullptr;
-
- if (parsedValue->isPositive().valueOr(true))
- return parsedValue;
-
- return nullptr;
+ return CSSPrimitiveValue::create(*perspective, CSSUnitType::CSS_PX);
}
#if ENABLE(CSS_SCROLL_SNAP)
@@ -5027,15 +5035,14 @@
} else {
unsigned index = 0;
while (!m_range.atEnd() && index++ < 3) {
- double num;
- if (consumeNumberRaw(m_range, num)) {
- if (num < 0)
+ if (auto num = consumeNumberRaw(m_range)) {
+ if (*num < 0)
return false;
if (flexGrow == unsetValue)
- flexGrow = num;
+ flexGrow = *num;
else if (flexShrink == unsetValue)
- flexShrink = num;
- else if (!num) // flex only allows a basis of 0 (sans units) if flex-grow and flex-shrink values have already been set.
+ flexShrink = *num;
+ else if (!*num) // flex only allows a basis of 0 (sans units) if flex-grow and flex-shrink values have already been set.
flexBasis = CSSPrimitiveValue::create(0, CSSUnitType::CSS_PX);
else
return false;
Modified: trunk/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp (272093 => 272094)
--- trunk/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp 2021-01-30 01:52:34 UTC (rev 272093)
+++ trunk/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp 2021-01-30 02:13:44 UTC (rev 272094)
@@ -1,5 +1,5 @@
// Copyright 2016 The Chromium Authors. All rights reserved.
-// Copyright (C) 2016 Apple Inc. All rights reserved.
+// Copyright (C) 2016-2021 Apple Inc. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
@@ -124,13 +124,12 @@
return CSSValuePool::singleton().createValue(m_calcValue->doubleValue(), CSSUnitType::CSS_NUMBER);
}
- bool consumeNumberRaw(double& result)
+ Optional<double> consumeNumberRaw()
{
if (!m_calcValue || m_calcValue->category() != CalculationCategory::Number)
- return false;
+ return WTF::nullopt;
m_sourceRange = m_range;
- result = m_calcValue->doubleValue();
- return true;
+ return m_calcValue->doubleValue();
}
Optional<double> consumePercentRaw()
@@ -212,21 +211,20 @@
return consumeInteger(range, 1);
}
-bool consumeNumberRaw(CSSParserTokenRange& range, double& result, ValueRange valueRange)
+Optional<double> consumeNumberRaw(CSSParserTokenRange& range, ValueRange valueRange)
{
const CSSParserToken& token = range.peek();
if (token.type() == NumberToken) {
if (valueRange == ValueRangeNonNegative && token.numericValue() < 0)
- return false;
- result = range.consumeIncludingWhitespace().numericValue();
- return true;
+ return WTF::nullopt;
+ return range.consumeIncludingWhitespace().numericValue();
}
if (token.type() != FunctionToken)
- return false;
+ return WTF::nullopt;
CalcParser calcParser(range, CalculationCategory::Number, valueRange);
- return calcParser.consumeNumberRaw(result);
+ return calcParser.consumeNumberRaw();
}
// FIXME: Work out if this can just call consumeNumberRaw
@@ -242,9 +240,8 @@
return nullptr;
}
- double number;
- if (consumeNumberRaw(range, number, valueRange))
- return CSSValuePool::singleton().createValue(number, token.unitType());
+ if (auto number = consumeNumberRaw(range, valueRange))
+ return CSSValuePool::singleton().createValue(*number, token.unitType());
return nullptr;
}
@@ -264,12 +261,8 @@
#if !ENABLE(VARIATION_FONTS)
&& token.numericValueType() == IntegerValueType && divisibleBy100(token.numericValue())
#endif
- ) {
- double result;
- if (consumeNumberRaw(range, result))
- return result;
- return WTF::nullopt;
- }
+ )
+ return consumeNumberRaw(range);
if (token.type() != FunctionToken)
return WTF::nullopt;
@@ -276,15 +269,12 @@
// "[For calc()], the used value resulting from an _expression_ must be clamped to the range allowed in the target context."
CalcParser calcParser(range, CalculationCategory::Number, ValueRangeAll);
- double result;
- if (calcParser.consumeNumberRaw(result)
+ if (auto result = calcParser.consumeNumberRaw(); result
#if !ENABLE(VARIATION_FONTS)
- && result > 0 && result < 1000 && divisibleBy100(result)
+ && *result > 0 && *result < 1000 && divisibleBy100(*result)
#endif
- ) {
- result = std::min(std::max(result, std::nextafter(0., 1.)), std::nextafter(1000., 0.));
- return result;
- }
+ )
+ return std::min(std::max(*result, std::nextafter(0., 1.)), std::nextafter(1000., 0.));
return WTF::nullopt;
}
@@ -681,13 +671,13 @@
bool isPercentage = false;
double colorParameter;
- if (!consumeNumberRaw(args, colorParameter)) {
- if (auto percent = consumePercentRaw(args)) {
- colorParameter = *percent;
- isPercentage = true;
- } else
- return Color();
- }
+ if (auto number = consumeNumberRaw(args))
+ colorParameter = *number;
+ else if (auto percent = consumePercentRaw(args)) {
+ colorParameter = *percent;
+ isPercentage = true;
+ } else
+ return { };
enum class ColorSyntax {
Commas,
@@ -708,18 +698,19 @@
if (i == 1)
syntax = consumeCommaIncludingWhitespace(args) ? ColorSyntax::Commas : ColorSyntax::WhitespaceSlash;
else if (!consumeSeparator())
- return Color();
+ return { };
if (isPercentage) {
- if (auto percent = consumePercentRaw(args))
- colorParameter = *percent;
- else
- return Color();
+ auto percent = consumePercentRaw(args);
+ if (!percent)
+ return { };
+ colorArray[i] = clampRGBComponent(*percent, true);
} else {
- if (!consumeNumberRaw(args, colorParameter))
- return Color();
+ auto number = consumeNumberRaw(args);
+ if (!number)
+ return { };
+ colorArray[i] = clampRGBComponent(*number, false);
}
- colorArray[i] = clampRGBComponent(colorParameter, isPercentage);
}
// Historically, alpha was only parsed for rgba(), but css-color-4 specifies that rgba() is a simple alias for rgb().
@@ -732,18 +723,16 @@
uint8_t alphaComponent = 255;
if (consumeAlphaSeparator()) {
- double alpha;
- if (!consumeNumberRaw(args, alpha)) {
- if (auto percent = consumePercentRaw(args))
- alpha = *percent / 100.0;
- else
- return Color();
- }
- alphaComponent = convertFloatAlphaTo<uint8_t>(alpha);
+ if (auto number = consumeNumberRaw(args))
+ alphaComponent = convertFloatAlphaTo<uint8_t>(*number);
+ else if (auto percent = consumePercentRaw(args))
+ alphaComponent = convertFloatAlphaTo<uint8_t>(*percent / 100.0);
+ else
+ return { };
};
if (!args.atEnd())
- return Color();
+ return { };
return SRGBA<uint8_t> { colorArray[0], colorArray[1], colorArray[2], alphaComponent };
}
@@ -752,47 +741,49 @@
{
ASSERT(range.peek().functionId() == CSSValueHsl || range.peek().functionId() == CSSValueHsla);
CSSParserTokenRange args = consumeFunction(range);
- double angleInDegrees;
+
+ double hueAngleInDegrees;
if (auto angle = consumeAngleRaw(args, cssParserMode, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Forbid))
- angleInDegrees = CSSPrimitiveValue::computeDegrees(angle->type, angle->value);
- else {
- if (!consumeNumberRaw(args, angleInDegrees))
- return Color();
- }
+ hueAngleInDegrees = CSSPrimitiveValue::computeDegrees(angle->type, angle->value);
+ else if (auto number = consumeNumberRaw(args))
+ hueAngleInDegrees = *number;
+ else
+ return { };
double colorArray[3];
- colorArray[0] = fmod(fmod(angleInDegrees, 360.0) + 360.0, 360.0) / 360.0;
+ colorArray[0] = fmod(fmod(hueAngleInDegrees, 360.0) + 360.0, 360.0) / 360.0;
+
bool requiresCommas = false;
for (int i = 1; i < 3; i++) {
if (consumeCommaIncludingWhitespace(args)) {
if (i != 1 && !requiresCommas)
- return Color();
+ return { };
requiresCommas = true;
} else if (requiresCommas || args.atEnd() || (&args.peek() - 1)->type() != WhitespaceToken)
- return Color();
+ return { };
auto percent = consumePercentRaw(args);
if (!percent)
- return Color();
+ return { };
colorArray[i] = clampTo<double>(*percent, 0.0, 100.0) / 100.0; // Needs to be value between 0 and 1.0.
}
- double alpha = 1.0;
bool commaConsumed = consumeCommaIncludingWhitespace(args);
bool slashConsumed = consumeSlashIncludingWhitespace(args);
if ((commaConsumed && !requiresCommas) || (slashConsumed && requiresCommas))
- return Color();
+ return { };
+
+ double alpha = 1.0;
if (commaConsumed || slashConsumed) {
- if (!consumeNumberRaw(args, alpha)) {
- if (auto percent = consumePercentRaw(args))
- alpha = *percent / 100.0f;
- else
- return Color();
- }
- alpha = clampTo<double>(alpha, 0.0, 1.0);
+ if (auto number = consumeNumberRaw(args))
+ alpha = clampTo<double>(*number, 0.0, 1.0);
+ else if (auto percent = consumePercentRaw(args))
+ alpha = clampTo<double>(*percent / 100.0f, 0.0, 1.0);
+ else
+ return { };
}
if (!args.atEnd())
- return Color();
+ return { };
return convertTo<SRGBA<uint8_t>>(toSRGBA(HSLA<float> { static_cast<float>(colorArray[0]), static_cast<float>(colorArray[1]), static_cast<float>(colorArray[2]), static_cast<float>(alpha) }));
}
@@ -805,11 +796,10 @@
if (auto alphaParameter = consumePercentRaw(range, ValueRangeAll))
return clampTo<float>(*alphaParameter / 100.0, 0.0, 1.0);
- double alphaParameter;
- if (!consumeNumberRaw(range, alphaParameter, ValueRangeAll))
- return WTF::nullopt;
+ if (auto alphaParameter = consumeNumberRaw(range, ValueRangeAll))
+ return clampTo<float>(*alphaParameter, 0.0, 1.0);
- return clampTo<float>(alphaParameter, 0.0, 1.0);
+ return WTF::nullopt;
}
static Color parseLabParameters(CSSParserTokenRange& range)
@@ -821,12 +811,12 @@
if (!lightness)
return { };
- double aValue;
- if (!consumeNumberRaw(args, aValue, ValueRangeAll))
+ auto aValue = consumeNumberRaw(args, ValueRangeAll);
+ if (!aValue)
return { };
- double bValue;
- if (!consumeNumberRaw(args, bValue, ValueRangeAll))
+ auto bValue = consumeNumberRaw(args, ValueRangeAll);
+ if (!bValue)
return { };
auto alpha = parseOptionalAlpha(args);
@@ -836,7 +826,7 @@
if (!args.atEnd())
return { };
- return Lab<float> { static_cast<float>(*lightness), static_cast<float>(aValue), static_cast<float>(bValue), *alpha };
+ return Lab<float> { static_cast<float>(*lightness), static_cast<float>(*aValue), static_cast<float>(*bValue), *alpha };
}
static Color parseLCHParameters(CSSParserTokenRange& range, CSSParserMode cssParserMode)
@@ -846,23 +836,23 @@
auto lightness = consumePercentRaw(args, ValueRangeAll);
if (!lightness)
- return Color();
+ return { };
- double chromaValue;
- if (!consumeNumberRaw(args, chromaValue, ValueRangeAll))
+ auto chromaValue = consumeNumberRaw(args, ValueRangeAll);
+ if (!chromaValue)
return { };
- double angleInDegrees;
- if (auto hueValue = consumeAngleRaw(args, cssParserMode, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Forbid))
- angleInDegrees = CSSPrimitiveValue::computeDegrees(hueValue->type, hueValue->value);
- else {
- if (!consumeNumberRaw(args, angleInDegrees, ValueRangeAll))
- return { };
- }
+ double hueAngleInDegrees;
+ if (auto angle = consumeAngleRaw(args, cssParserMode, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Forbid))
+ hueAngleInDegrees = CSSPrimitiveValue::computeDegrees(angle->type, angle->value);
+ else if (auto number = consumeNumberRaw(args, ValueRangeAll))
+ hueAngleInDegrees = *number;
+ else
+ return { };
- angleInDegrees = fmod(angleInDegrees, 360.0);
- if (angleInDegrees < 0.0)
- angleInDegrees += 360.0;
+ hueAngleInDegrees = fmod(hueAngleInDegrees, 360.0);
+ if (hueAngleInDegrees < 0.0)
+ hueAngleInDegrees += 360.0;
auto alpha = parseOptionalAlpha(args);
if (!alpha)
@@ -871,7 +861,7 @@
if (!args.atEnd())
return { };
- return toLab(LCHA<float> { static_cast<float>(*lightness), static_cast<float>(chromaValue), static_cast<float>(angleInDegrees), *alpha });
+ return toLab(LCHA<float> { static_cast<float>(*lightness), static_cast<float>(*chromaValue), static_cast<float>(hueAngleInDegrees), *alpha });
}
template<typename ColorType>
@@ -882,9 +872,8 @@
double channels[3] = { 0, 0, 0 };
for (int i = 0; i < 3; ++i) {
- double value;
- if (consumeNumberRaw(args, value))
- channels[i] = value;
+ if (auto number = consumeNumberRaw(args))
+ channels[i] = *number;
else if (auto percent = consumePercentRaw(args))
channels[i] = *percent / 100.0;
else
@@ -910,15 +899,15 @@
return;
channels[0] = *lightness;
- double aValue;
- if (!consumeNumberRaw(args, aValue, ValueRangeAll))
+ auto aValue = consumeNumberRaw(args, ValueRangeAll);
+ if (!aValue)
return;
- channels[1] = aValue;
+ channels[1] = *aValue;
- double bValue;
- if (!consumeNumberRaw(args, bValue, ValueRangeAll))
+ auto bValue = consumeNumberRaw(args, ValueRangeAll);
+ if (!bValue)
return;
- channels[2] = bValue;
+ channels[2] = *bValue;
}();
auto alpha = parseOptionalAlpha(args);
@@ -1023,7 +1012,7 @@
color = parseColorFunctionParameters(colorRange);
break;
default:
- return Color();
+ return { };
}
if (color.isValid())
range = colorRange;
@@ -1038,9 +1027,9 @@
// FIXME: Need a worker-safe way to compute the system colors.
// For now, we detect the system color, but then intentionally fail parsing.
if (StyleColor::isSystemColor(keyword))
- return Color();
+ return { };
if (!isValueAllowedInMode(keyword, cssParserMode))
- return Color();
+ return { };
result = StyleColor::colorFromKeyword(keyword, { });
range.consumeIncludingWhitespace();
}
@@ -1051,7 +1040,7 @@
result = parseColorFunction(range, cssParserMode);
if (!range.atEnd())
- return Color();
+ return { };
return result;
}
@@ -1321,9 +1310,11 @@
position = (id == CSSValueFrom) ? 0 : 1;
} else {
ASSERT(id == CSSValueColorStop);
- if (auto percentValue = consumePercent(args, ValueRangeAll))
- position = percentValue->doubleValue() / 100.0;
- else if (!consumeNumberRaw(args, position))
+ if (auto percent = consumePercentRaw(args, ValueRangeAll))
+ position = *percent / 100.0;
+ else if (auto number = consumeNumberRaw(args))
+ position = *number;
+ else
return false;
if (!consumeCommaIncludingWhitespace(args))
@@ -2171,9 +2162,8 @@
return WTF::nullopt;
}
- double number;
- if (consumeNumberRaw(range, number, ValueRangeNonNegative))
- return { number };
+ if (auto number = consumeNumberRaw(range, ValueRangeNonNegative))
+ return { *number };
if (auto lengthOrPercent = consumeLengthOrPercentRaw(range, cssParserMode, ValueRangeNonNegative))
return { *lengthOrPercent };
