blob: b949cc8bd60c948f67c95ae747a70763df54f5c4 [file] [log] [blame]
// Copyright 2014 The Chromium Authors. All rights reserved.
// Copyright (C) 2016-2018 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
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "config.h"
#include "CSSParserFastPaths.h"
#include "CSSFunctionValue.h"
#include "CSSParserContext.h"
#include "CSSParserIdioms.h"
#include "CSSPrimitiveValue.h"
#include "CSSPropertyParser.h"
#include "CSSValueList.h"
#include "CSSValuePool.h"
#include "HTMLParserIdioms.h"
#include "RuntimeEnabledFeatures.h"
#include "StyleColor.h"
#include "StylePropertyShorthand.h"
namespace WebCore {
static inline bool isSimpleLengthPropertyID(CSSPropertyID propertyId, bool& acceptsNegativeNumbers)
{
switch (propertyId) {
case CSSPropertyFontSize:
case CSSPropertyHeight:
case CSSPropertyWidth:
case CSSPropertyMinHeight:
case CSSPropertyMinWidth:
case CSSPropertyPaddingBottom:
case CSSPropertyPaddingLeft:
case CSSPropertyPaddingRight:
case CSSPropertyPaddingTop:
case CSSPropertyInlineSize:
case CSSPropertyBlockSize:
case CSSPropertyMinInlineSize:
case CSSPropertyMinBlockSize:
case CSSPropertyPaddingBlockEnd:
case CSSPropertyPaddingBlockStart:
case CSSPropertyPaddingInlineEnd:
case CSSPropertyPaddingInlineStart:
case CSSPropertyShapeMargin:
acceptsNegativeNumbers = false;
return true;
case CSSPropertyBottom:
case CSSPropertyCx:
case CSSPropertyCy:
case CSSPropertyLeft:
case CSSPropertyInsetBlockEnd:
case CSSPropertyInsetBlockStart:
case CSSPropertyInsetInlineEnd:
case CSSPropertyInsetInlineStart:
case CSSPropertyMarginBottom:
case CSSPropertyMarginLeft:
case CSSPropertyMarginRight:
case CSSPropertyMarginTop:
case CSSPropertyRight:
case CSSPropertyTop:
case CSSPropertyMarginBlockEnd:
case CSSPropertyMarginBlockStart:
case CSSPropertyMarginInlineEnd:
case CSSPropertyMarginInlineStart:
case CSSPropertyX:
case CSSPropertyY:
case CSSPropertyR:
case CSSPropertyRx:
case CSSPropertyRy:
acceptsNegativeNumbers = true;
return true;
default:
return false;
}
}
template <typename CharacterType>
static inline bool parseSimpleLength(const CharacterType* characters, unsigned length, CSSPrimitiveValue::UnitType& unit, double& number)
{
if (length > 2 && (characters[length - 2] | 0x20) == 'p' && (characters[length - 1] | 0x20) == 'x') {
length -= 2;
unit = CSSPrimitiveValue::UnitType::CSS_PX;
} else if (length > 1 && characters[length - 1] == '%') {
length -= 1;
unit = CSSPrimitiveValue::UnitType::CSS_PERCENTAGE;
}
// We rely on charactersToDouble for validation as well. The function
// will set "ok" to "false" if the entire passed-in character range does
// not represent a double.
bool ok;
number = charactersToDouble(characters, length, &ok);
if (!ok)
return false;
return true;
}
template <typename CharacterType>
static inline bool parseSimpleAngle(const CharacterType* characters, unsigned length, CSSPrimitiveValue::UnitType& unit, double& number)
{
// Just support deg and rad for now.
if (length < 4)
return false;
if ((characters[length - 3] | 0x20) == 'd' && (characters[length - 2] | 0x20) == 'e' && (characters[length - 1] | 0x20) == 'g') {
length -= 3;
unit = CSSPrimitiveValue::UnitType::CSS_DEG;
} else if ((characters[length - 3] | 0x20) == 'r' && (characters[length - 2] | 0x20) == 'a' && (characters[length - 1] | 0x20) == 'd') {
length -= 3;
unit = CSSPrimitiveValue::UnitType::CSS_RAD;
} else
return false;
// We rely on charactersToDouble for validation as well. The function
// will set "ok" to "false" if the entire passed-in character range does
// not represent a double.
bool ok;
number = charactersToDouble(characters, length, &ok);
if (!ok)
return false;
return true;
}
static RefPtr<CSSValue> parseSimpleLengthValue(CSSPropertyID propertyId, const String& string, CSSParserMode cssParserMode)
{
ASSERT(!string.isEmpty());
bool acceptsNegativeNumbers = false;
// In @viewport, width and height are shorthands, not simple length values.
if (isCSSViewportParsingEnabledForMode(cssParserMode) || !isSimpleLengthPropertyID(propertyId, acceptsNegativeNumbers))
return nullptr;
unsigned length = string.length();
double number;
CSSPrimitiveValue::UnitType unit = CSSPrimitiveValue::UnitType::CSS_NUMBER;
if (string.is8Bit()) {
if (!parseSimpleLength(string.characters8(), length, unit, number))
return nullptr;
} else {
if (!parseSimpleLength(string.characters16(), length, unit, number))
return nullptr;
}
if (unit == CSSPrimitiveValue::UnitType::CSS_NUMBER) {
if (number && cssParserMode != SVGAttributeMode)
return nullptr;
unit = CSSPrimitiveValue::UnitType::CSS_PX;
}
if (number < 0 && !acceptsNegativeNumbers)
return nullptr;
if (std::isinf(number))
return nullptr;
return CSSPrimitiveValue::create(number, unit);
}
static inline bool isColorPropertyID(CSSPropertyID propertyId)
{
switch (propertyId) {
case CSSPropertyColor:
case CSSPropertyBackgroundColor:
case CSSPropertyBorderBottomColor:
case CSSPropertyBorderLeftColor:
case CSSPropertyBorderRightColor:
case CSSPropertyBorderTopColor:
case CSSPropertyFill:
case CSSPropertyFloodColor:
case CSSPropertyLightingColor:
case CSSPropertyOutlineColor:
case CSSPropertyStopColor:
case CSSPropertyStroke:
case CSSPropertyStrokeColor:
case CSSPropertyBorderBlockEndColor:
case CSSPropertyBorderBlockStartColor:
case CSSPropertyBorderInlineEndColor:
case CSSPropertyBorderInlineStartColor:
case CSSPropertyColumnRuleColor:
case CSSPropertyWebkitTextEmphasisColor:
case CSSPropertyWebkitTextFillColor:
case CSSPropertyWebkitTextStrokeColor:
case CSSPropertyTextDecorationColor:
return true;
default:
return false;
}
}
// Returns the number of characters which form a valid double
// and are terminated by the given terminator character
template <typename CharacterType>
static int checkForValidDouble(const CharacterType* string, const CharacterType* end, const char terminator)
{
int length = end - string;
if (length < 1)
return 0;
bool decimalMarkSeen = false;
int processedLength = 0;
for (int i = 0; i < length; ++i) {
if (string[i] == terminator) {
processedLength = i;
break;
}
if (!isASCIIDigit(string[i])) {
if (!decimalMarkSeen && string[i] == '.')
decimalMarkSeen = true;
else
return 0;
}
}
if (decimalMarkSeen && processedLength == 1)
return 0;
return processedLength;
}
// Returns the number of characters consumed for parsing a valid double
// terminated by the given terminator character
template <typename CharacterType>
static int parseDouble(const CharacterType* string, const CharacterType* end, const char terminator, double& value)
{
int length = checkForValidDouble(string, end, terminator);
if (!length)
return 0;
int position = 0;
double localValue = 0;
// The consumed characters here are guaranteed to be
// ASCII digits with or without a decimal mark
for (; position < length; ++position) {
if (string[position] == '.')
break;
localValue = localValue * 10 + string[position] - '0';
}
if (++position == length) {
value = localValue;
return length;
}
double fraction = 0;
double scale = 1;
const double maxScale = 1000000;
while (position < length && scale < maxScale) {
fraction = fraction * 10 + string[position++] - '0';
scale *= 10;
}
value = localValue + fraction / scale;
return length;
}
template <typename CharacterType>
static bool parseColorIntOrPercentage(const CharacterType*& string, const CharacterType* end, const char terminator, CSSPrimitiveValue::UnitType& expect, int& value)
{
const CharacterType* current = string;
double localValue = 0;
bool negative = false;
while (current != end && isHTMLSpace<CharacterType>(*current))
current++;
if (current != end && *current == '-') {
negative = true;
current++;
}
if (current == end || !isASCIIDigit(*current))
return false;
while (current != end && isASCIIDigit(*current)) {
double newValue = localValue * 10 + *current++ - '0';
if (newValue >= 255) {
// Clamp values at 255.
localValue = 255;
while (current != end && isASCIIDigit(*current))
++current;
break;
}
localValue = newValue;
}
if (current == end)
return false;
if (expect == CSSPrimitiveValue::UnitType::CSS_NUMBER && (*current == '.' || *current == '%'))
return false;
if (*current == '.') {
// We already parsed the integral part, try to parse
// the fraction part of the percentage value.
double percentage = 0;
int numCharactersParsed = parseDouble(current, end, '%', percentage);
if (!numCharactersParsed)
return false;
current += numCharactersParsed;
if (*current != '%')
return false;
localValue += percentage;
}
if (expect == CSSPrimitiveValue::UnitType::CSS_PERCENTAGE && *current != '%')
return false;
if (*current == '%') {
expect = CSSPrimitiveValue::UnitType::CSS_PERCENTAGE;
localValue = localValue / 100.0 * 256.0;
// Clamp values at 255 for percentages over 100%
if (localValue > 255)
localValue = 255;
current++;
} else {
expect = CSSPrimitiveValue::UnitType::CSS_NUMBER;
}
while (current != end && isHTMLSpace<CharacterType>(*current))
current++;
if (current == end || *current++ != terminator)
return false;
// Clamp negative values at zero.
value = negative ? 0 : static_cast<int>(localValue);
string = current;
return true;
}
template <typename CharacterType>
static inline bool isTenthAlpha(const CharacterType* string, const int length)
{
// "0.X"
if (length == 3 && string[0] == '0' && string[1] == '.' && isASCIIDigit(string[2]))
return true;
// ".X"
if (length == 2 && string[0] == '.' && isASCIIDigit(string[1]))
return true;
return false;
}
template <typename CharacterType>
static inline bool parseAlphaValue(const CharacterType*& string, const CharacterType* end, const char terminator, int& value)
{
while (string != end && isHTMLSpace<CharacterType>(*string))
string++;
bool negative = false;
if (string != end && *string == '-') {
negative = true;
string++;
}
value = 0;
int length = end - string;
if (length < 2)
return false;
if (string[length - 1] != terminator || !isASCIIDigit(string[length - 2]))
return false;
if (string[0] != '0' && string[0] != '1' && string[0] != '.') {
if (checkForValidDouble(string, end, terminator)) {
value = negative ? 0 : 255;
string = end;
return true;
}
return false;
}
if (length == 2 && string[0] != '.') {
value = !negative && string[0] == '1' ? 255 : 0;
string = end;
return true;
}
if (isTenthAlpha(string, length - 1)) {
static const int tenthAlphaValues[] = { 0, 25, 51, 76, 102, 127, 153, 179, 204, 230 };
value = negative ? 0 : tenthAlphaValues[string[length - 2] - '0'];
string = end;
return true;
}
double alpha = 0;
if (!parseDouble(string, end, terminator, alpha))
return false;
value = negative ? 0 : static_cast<int>(alpha * nextafter(256.0, 0.0));
string = end;
return true;
}
template <typename CharacterType>
static inline bool mightBeRGBA(const CharacterType* characters, unsigned length)
{
if (length < 5)
return false;
return characters[4] == '('
&& isASCIIAlphaCaselessEqual(characters[0], 'r')
&& isASCIIAlphaCaselessEqual(characters[1], 'g')
&& isASCIIAlphaCaselessEqual(characters[2], 'b')
&& isASCIIAlphaCaselessEqual(characters[3], 'a');
}
template <typename CharacterType>
static inline bool mightBeRGB(const CharacterType* characters, unsigned length)
{
if (length < 4)
return false;
return characters[3] == '('
&& isASCIIAlphaCaselessEqual(characters[0], 'r')
&& isASCIIAlphaCaselessEqual(characters[1], 'g')
&& isASCIIAlphaCaselessEqual(characters[2], 'b');
}
template <typename CharacterType>
static Color fastParseColorInternal(const CharacterType* characters, unsigned length, bool quirksMode)
{
CSSPrimitiveValue::UnitType expect = CSSPrimitiveValue::UnitType::CSS_UNKNOWN;
if (length >= 4 && characters[0] == '#') {
RGBA32 rgb;
if (Color::parseHexColor(characters + 1, length - 1, rgb))
return Color(rgb);
}
if (quirksMode && (length == 3 || length == 6)) {
RGBA32 rgb;
if (Color::parseHexColor(characters, length, rgb))
return Color(rgb);
}
// Try rgba() syntax.
if (mightBeRGBA(characters, length)) {
const CharacterType* current = characters + 5;
const CharacterType* end = characters + length;
int red;
int green;
int blue;
int alpha;
if (!parseColorIntOrPercentage(current, end, ',', expect, red))
return Color();
if (!parseColorIntOrPercentage(current, end, ',', expect, green))
return Color();
if (!parseColorIntOrPercentage(current, end, ',', expect, blue))
return Color();
if (!parseAlphaValue(current, end, ')', alpha))
return Color();
if (current != end)
return Color();
return Color(makeRGBA(red, green, blue, alpha));
}
// Try rgb() syntax.
if (mightBeRGB(characters, length)) {
const CharacterType* current = characters + 4;
const CharacterType* end = characters + length;
int red;
int green;
int blue;
if (!parseColorIntOrPercentage(current, end, ',', expect, red))
return Color();
if (!parseColorIntOrPercentage(current, end, ',', expect, green))
return Color();
if (!parseColorIntOrPercentage(current, end, ')', expect, blue))
return Color();
if (current != end)
return Color();
return Color(makeRGB(red, green, blue));
}
return Color();
}
RefPtr<CSSValue> CSSParserFastPaths::parseColor(const String& string, CSSParserMode parserMode)
{
ASSERT(!string.isEmpty());
CSSValueID valueID = cssValueKeywordID(string);
if (StyleColor::isColorKeyword(valueID)) {
if (!isValueAllowedInMode(valueID, parserMode))
return nullptr;
return CSSValuePool::singleton().createIdentifierValue(valueID);
}
bool quirksMode = isQuirksModeBehavior(parserMode);
// Fast path for hex colors and rgb()/rgba() colors
Color color;
if (string.is8Bit())
color = fastParseColorInternal(string.characters8(), string.length(), quirksMode);
else
color = fastParseColorInternal(string.characters16(), string.length(), quirksMode);
if (!color.isValid())
return nullptr;
return CSSValuePool::singleton().createColorValue(color);
}
bool CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyID propertyId, CSSValueID valueID, const CSSParserContext& context)
{
#if !ENABLE(OVERFLOW_SCROLLING_TOUCH)
UNUSED_PARAM(context);
#endif
if (valueID == CSSValueInvalid || !isValueAllowedInMode(valueID, context.mode))
return false;
switch (propertyId) {
case CSSPropertyAlignmentBaseline:
// auto | baseline | before-edge | text-before-edge | middle |
// central | after-edge | text-after-edge | ideographic | alphabetic |
// hanging | mathematical
return valueID == CSSValueAuto || valueID == CSSValueAlphabetic || valueID == CSSValueBaseline
|| valueID == CSSValueMiddle || (valueID >= CSSValueBeforeEdge && valueID <= CSSValueMathematical);
case CSSPropertyAll:
return false; // Only accepts css-wide keywords
case CSSPropertyBackgroundRepeatX: // repeat | no-repeat
case CSSPropertyBackgroundRepeatY: // repeat | no-repeat
return valueID == CSSValueRepeat || valueID == CSSValueNoRepeat;
case CSSPropertyBorderCollapse: // collapse | separate
return valueID == CSSValueCollapse || valueID == CSSValueSeparate;
case CSSPropertyBorderTopStyle: // <border-style>
case CSSPropertyBorderRightStyle: // Defined as: none | hidden | dotted | dashed |
case CSSPropertyBorderBottomStyle: // solid | double | groove | ridge | inset | outset
case CSSPropertyBorderLeftStyle:
case CSSPropertyBorderBlockEndStyle:
case CSSPropertyBorderBlockStartStyle:
case CSSPropertyBorderInlineEndStyle:
case CSSPropertyBorderInlineStartStyle:
case CSSPropertyColumnRuleStyle:
return valueID >= CSSValueNone && valueID <= CSSValueDouble;
case CSSPropertyBoxSizing:
return valueID == CSSValueBorderBox || valueID == CSSValueContentBox;
case CSSPropertyBufferedRendering:
return valueID == CSSValueAuto || valueID == CSSValueDynamic || valueID == CSSValueStatic;
case CSSPropertyCaptionSide: // top | bottom | left | right
return valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueTop || valueID == CSSValueBottom;
case CSSPropertyClear: // none | left | right | both
return valueID == CSSValueNone || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueBoth;
case CSSPropertyClipRule:
case CSSPropertyFillRule:
return valueID == CSSValueNonzero || valueID == CSSValueEvenodd;
case CSSPropertyColorInterpolation:
case CSSPropertyColorInterpolationFilters:
return valueID == CSSValueAuto || valueID == CSSValueSRGB || valueID == CSSValueLinearRGB;
case CSSPropertyColorRendering:
return valueID == CSSValueAuto || valueID == CSSValueOptimizeSpeed || valueID == CSSValueOptimizeQuality;
case CSSPropertyDirection: // ltr | rtl
return valueID == CSSValueLtr || valueID == CSSValueRtl;
case CSSPropertyDisplay:
// inline | block | list-item | inline-block | table |
// inline-table | table-row-group | table-header-group | table-footer-group | table-row |
// table-column-group | table-column | table-cell | table-caption | -webkit-box | -webkit-inline-box | none
// flex | inline-flex | -webkit-flex | -webkit-inline-flex | grid | inline-grid
return (valueID >= CSSValueInline && valueID <= CSSValueContents) || valueID == CSSValueNone
|| valueID == CSSValueGrid || valueID == CSSValueInlineGrid || valueID == CSSValueFlowRoot;
case CSSPropertyDominantBaseline:
// auto | use-script | no-change | reset-size | ideographic |
// alphabetic | hanging | mathematical | central | middle |
// text-after-edge | text-before-edge
return valueID == CSSValueAuto || valueID == CSSValueAlphabetic || valueID == CSSValueMiddle
|| (valueID >= CSSValueUseScript && valueID <= CSSValueResetSize)
|| (valueID >= CSSValueCentral && valueID <= CSSValueMathematical);
case CSSPropertyEmptyCells: // show | hide
return valueID == CSSValueShow || valueID == CSSValueHide;
case CSSPropertyFloat: // left | right | none
return valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueNone;
case CSSPropertyImageRendering: // auto | optimizeContrast | pixelated | optimizeSpeed | crispEdges | optimizeQuality | webkit-crispEdges
return valueID == CSSValueAuto || valueID == CSSValueOptimizeSpeed || valueID == CSSValueOptimizeQuality || valueID == CSSValueWebkitCrispEdges || valueID == CSSValueWebkitOptimizeContrast || valueID == CSSValueCrispEdges || valueID == CSSValuePixelated;
#if ENABLE(CSS_COMPOSITING)
case CSSPropertyIsolation: // auto | isolate
return valueID == CSSValueAuto || valueID == CSSValueIsolate;
#endif
case CSSPropertyListStylePosition: // inside | outside
return valueID == CSSValueInside || valueID == CSSValueOutside;
case CSSPropertyListStyleType:
// See section CSS_PROP_LIST_STYLE_TYPE of file CSSValueKeywords.in
// for the list of supported list-style-types.
return (valueID >= CSSValueDisc && valueID <= CSSValueKatakanaIroha) || valueID == CSSValueNone;
case CSSPropertyMaskType:
return valueID == CSSValueLuminance || valueID == CSSValueAlpha;
case CSSPropertyObjectFit:
return valueID == CSSValueFill || valueID == CSSValueContain || valueID == CSSValueCover || valueID == CSSValueNone || valueID == CSSValueScaleDown;
case CSSPropertyOutlineStyle: // (<border-style> except hidden) | auto
return valueID == CSSValueAuto || valueID == CSSValueNone || (valueID >= CSSValueInset && valueID <= CSSValueDouble);
// FIXME-NEWPARSER: Support?
// case CSSPropertyOverflowAnchor:
// return valueID == CSSValueVisible || valueID == CSSValueNone || valueID == CSSValueAuto;
case CSSPropertyOverflowWrap: // normal | break-word
case CSSPropertyWordWrap:
return valueID == CSSValueNormal || valueID == CSSValueBreakWord;
case CSSPropertyOverflowX: // visible | hidden | scroll | auto | overlay (overlay is a synonym for auto)
return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueScroll || valueID == CSSValueAuto || valueID == CSSValueOverlay;
case CSSPropertyOverflowY: // visible | hidden | scroll | auto | overlay | -webkit-paged-x | -webkit-paged-y (overlay is a synonym for auto)
return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueScroll || valueID == CSSValueAuto || valueID == CSSValueOverlay || valueID == CSSValueWebkitPagedX || valueID == CSSValueWebkitPagedY;
case CSSPropertyBreakAfter:
case CSSPropertyBreakBefore:
return valueID == CSSValueAuto || valueID == CSSValueAvoid || valueID == CSSValueAvoidPage || valueID == CSSValuePage || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueRecto || valueID == CSSValueVerso || valueID == CSSValueAvoidColumn || valueID == CSSValueColumn;
case CSSPropertyBreakInside:
return valueID == CSSValueAuto || valueID == CSSValueAvoid || valueID == CSSValueAvoidPage || valueID == CSSValueAvoidColumn;
case CSSPropertyPointerEvents:
// none | visiblePainted | visibleFill | visibleStroke | visible |
// painted | fill | stroke | auto | all | bounding-box
return valueID == CSSValueVisible || valueID == CSSValueNone || valueID == CSSValueAll || valueID == CSSValueAuto || (valueID >= CSSValueVisiblePainted && valueID <= CSSValueStroke);
case CSSPropertyPosition: // static | relative | absolute | fixed | sticky
return valueID == CSSValueStatic
|| valueID == CSSValueRelative
|| valueID == CSSValueAbsolute
|| valueID == CSSValueFixed
|| valueID == CSSValueSticky || valueID == CSSValueWebkitSticky;
case CSSPropertyResize: // none | both | horizontal | vertical | auto
return valueID == CSSValueNone || valueID == CSSValueBoth || valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueAuto;
// FIXME-NEWPARSER: Investigate this property.
// case CSSPropertyScrollBehavior: // auto | smooth
// ASSERT(RuntimeEnabledFeatures::cssomSmoothScrollEnabled());
// return valueID == CSSValueAuto || valueID == CSSValueSmooth;
case CSSPropertyShapeRendering:
return valueID == CSSValueAuto || valueID == CSSValueOptimizeSpeed || valueID == CSSValueCrispedges || valueID == CSSValueGeometricPrecision;
case CSSPropertyStrokeLinejoin:
return valueID == CSSValueMiter || valueID == CSSValueRound || valueID == CSSValueBevel;
case CSSPropertyStrokeLinecap:
return valueID == CSSValueButt || valueID == CSSValueRound || valueID == CSSValueSquare;
case CSSPropertyTableLayout: // auto | fixed
return valueID == CSSValueAuto || valueID == CSSValueFixed;
case CSSPropertyTextAlign:
return (valueID >= CSSValueWebkitAuto && valueID <= CSSValueWebkitMatchParent) || valueID == CSSValueStart || valueID == CSSValueEnd;
#if ENABLE(CSS3_TEXT)
case CSSPropertyWebkitTextAlignLast:
// auto | start | end | left | right | center | justify
return (valueID >= CSSValueLeft && valueID <= CSSValueJustify) || valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueAuto;
#endif
case CSSPropertyTextAnchor:
return valueID == CSSValueStart || valueID == CSSValueMiddle || valueID == CSSValueEnd;
// FIXME-NEWPARSER: Support
// case CSSPropertyTextCombineUpright:
// return valueID == CSSValueNone || valueID == CSSValueAll;
case CSSPropertyTextDecorationStyle:
// solid | double | dotted | dashed | wavy
return valueID == CSSValueSolid || valueID == CSSValueDouble || valueID == CSSValueDotted || valueID == CSSValueDashed || valueID == CSSValueWavy;
#if ENABLE(CSS3_TEXT)
case CSSPropertyWebkitTextJustify:
// auto | none | inter-word | distribute
return valueID == CSSValueInterWord || valueID == CSSValueDistribute || valueID == CSSValueAuto || valueID == CSSValueNone;
#endif
case CSSPropertyWebkitTextOrientation: // mixed | upright | sideways | sideways-right
return valueID == CSSValueMixed || valueID == CSSValueUpright || valueID == CSSValueSideways || valueID == CSSValueSidewaysRight;
case CSSPropertyTextOverflow: // clip | ellipsis
return valueID == CSSValueClip || valueID == CSSValueEllipsis;
case CSSPropertyTextRendering: // auto | optimizeSpeed | optimizeLegibility | geometricPrecision
return valueID == CSSValueAuto || valueID == CSSValueOptimizeSpeed || valueID == CSSValueOptimizeLegibility || valueID == CSSValueGeometricPrecision;
case CSSPropertyTextTransform: // capitalize | uppercase | lowercase | none
return (valueID >= CSSValueCapitalize && valueID <= CSSValueLowercase) || valueID == CSSValueNone;
case CSSPropertyUnicodeBidi:
return valueID == CSSValueNormal || valueID == CSSValueEmbed
|| valueID == CSSValueBidiOverride
|| valueID == CSSValueIsolate || valueID == CSSValueWebkitIsolate
|| valueID == CSSValueIsolateOverride || valueID == CSSValueWebkitIsolateOverride
|| valueID == CSSValuePlaintext || valueID == CSSValueWebkitPlaintext;
case CSSPropertyVectorEffect:
return valueID == CSSValueNone || valueID == CSSValueNonScalingStroke;
case CSSPropertyVisibility: // visible | hidden | collapse
return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueCollapse;
case CSSPropertyWebkitAppearance:
return (valueID >= CSSValueCheckbox && valueID <= CSSValueCapsLockIndicator) || valueID == CSSValueNone;
case CSSPropertyWebkitBackfaceVisibility:
return valueID == CSSValueVisible || valueID == CSSValueHidden;
#if ENABLE(CSS_COMPOSITING)
case CSSPropertyMixBlendMode:
return valueID == CSSValueNormal || valueID == CSSValueMultiply || valueID == CSSValueScreen || valueID == CSSValueOverlay
|| valueID == CSSValueDarken || valueID == CSSValueLighten || valueID == CSSValueColorDodge || valueID == CSSValueColorBurn
|| valueID == CSSValueHardLight || valueID == CSSValueSoftLight || valueID == CSSValueDifference || valueID == CSSValueExclusion
|| valueID == CSSValueHue || valueID == CSSValueSaturation || valueID == CSSValueColor || valueID == CSSValueLuminosity || valueID == CSSValuePlusDarker || valueID == CSSValuePlusLighter;
#endif
case CSSPropertyWebkitBoxAlign:
return valueID == CSSValueStretch || valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline;
#if ENABLE(CSS_BOX_DECORATION_BREAK)
case CSSPropertyWebkitBoxDecorationBreak:
return valueID == CSSValueClone || valueID == CSSValueSlice;
case CSSPropertyWebkitBoxDirection:
return valueID == CSSValueNormal || valueID == CSSValueReverse;
#endif
case CSSPropertyWebkitBoxLines:
return valueID == CSSValueSingle || valueID == CSSValueMultiple;
case CSSPropertyWebkitBoxOrient:
return valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueInlineAxis || valueID == CSSValueBlockAxis;
case CSSPropertyWebkitBoxPack:
return valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueJustify;
#if ENABLE(CURSOR_VISIBILITY)
case CSSPropertyWebkitCursorVisibility:
return valueID == CSSValueAuto || valueID == CSSValueAutoHide;
#endif
case CSSPropertyColumnFill:
return valueID == CSSValueAuto || valueID == CSSValueBalance;
case CSSPropertyWebkitColumnAxis:
return valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueAuto;
case CSSPropertyWebkitColumnProgression:
return valueID == CSSValueNormal || valueID == CSSValueReverse;
case CSSPropertyFlexDirection:
return valueID == CSSValueRow || valueID == CSSValueRowReverse || valueID == CSSValueColumn || valueID == CSSValueColumnReverse;
case CSSPropertyFlexWrap:
return valueID == CSSValueNowrap || valueID == CSSValueWrap || valueID == CSSValueWrapReverse;
case CSSPropertyWebkitHyphens:
return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueManual;
case CSSPropertyWebkitFontKerning:
return valueID == CSSValueAuto || valueID == CSSValueNormal || valueID == CSSValueNone;
case CSSPropertyWebkitFontSmoothing:
return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueAntialiased || valueID == CSSValueSubpixelAntialiased;
case CSSPropertyWebkitLineAlign:
return valueID == CSSValueNone || valueID == CSSValueEdges;
case CSSPropertyLineBreak: // auto | loose | normal | strict | after-white-space | anywhere
return valueID == CSSValueAuto || valueID == CSSValueLoose || valueID == CSSValueNormal || valueID == CSSValueStrict || valueID == CSSValueAfterWhiteSpace || valueID == CSSValueAnywhere;
case CSSPropertyWebkitLineSnap:
return valueID == CSSValueNone || valueID == CSSValueBaseline || valueID == CSSValueContain;
case CSSPropertyWebkitMarginAfterCollapse:
case CSSPropertyWebkitMarginBeforeCollapse:
case CSSPropertyWebkitMarginBottomCollapse:
case CSSPropertyWebkitMarginTopCollapse:
return valueID == CSSValueCollapse || valueID == CSSValueSeparate || valueID == CSSValueDiscard;
case CSSPropertyWebkitPrintColorAdjust:
return valueID == CSSValueExact || valueID == CSSValueEconomy;
case CSSPropertyWebkitRtlOrdering:
return valueID == CSSValueLogical || valueID == CSSValueVisual;
case CSSPropertyWebkitRubyPosition:
return valueID == CSSValueBefore || valueID == CSSValueAfter || valueID == CSSValueInterCharacter;
case CSSPropertyWebkitTextCombine:
return valueID == CSSValueNone || valueID == CSSValueHorizontal;
case CSSPropertyWebkitTextSecurity: // disc | circle | square | none
return valueID == CSSValueDisc || valueID == CSSValueCircle || valueID == CSSValueSquare || valueID == CSSValueNone;
case CSSPropertyTransformStyle:
case CSSPropertyWebkitTransformStyle:
return valueID == CSSValueFlat || valueID == CSSValuePreserve3d;
case CSSPropertyWebkitUserDrag: // auto | none | element
return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueElement;
case CSSPropertyWebkitUserModify: // read-only | read-write
return valueID == CSSValueReadOnly || valueID == CSSValueReadWrite || valueID == CSSValueReadWritePlaintextOnly;
case CSSPropertyWebkitUserSelect: // auto | none | text | all
return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueText || valueID == CSSValueAll;
case CSSPropertyWritingMode:
// Note that horizontal-bt is not supported by the unprefixed version of
// the property, only by the -webkit- version.
return (valueID >= CSSValueHorizontalTb && valueID <= CSSValueHorizontalBt)
|| valueID == CSSValueLrTb || valueID == CSSValueRlTb || valueID == CSSValueTbRl
|| valueID == CSSValueLr || valueID == CSSValueRl || valueID == CSSValueTb;
case CSSPropertyWhiteSpace: // normal | pre | nowrap | pre-line | nowrap | break-spacess
return valueID == CSSValueNormal || valueID == CSSValuePre || valueID == CSSValuePreWrap || valueID == CSSValuePreLine || valueID == CSSValueNowrap || valueID == CSSValueBreakSpaces;
case CSSPropertyWordBreak: // normal | break-all | keep-all | break-word (this is a custom extension)
return valueID == CSSValueNormal || valueID == CSSValueBreakAll || valueID == CSSValueKeepAll || valueID == CSSValueBreakWord;
case CSSPropertyWebkitBorderFit:
return valueID == CSSValueBorder || valueID == CSSValueLines;
#if ENABLE(CSS_TRAILING_WORD)
case CSSPropertyAppleTrailingWord: // auto | -apple-partially-balanced
return valueID == CSSValueAuto || valueID == CSSValueWebkitPartiallyBalanced;
#endif
#if ENABLE(APPLE_PAY)
case CSSPropertyApplePayButtonStyle: // white | white-outline | black
return valueID == CSSValueWhite || valueID == CSSValueWhiteOutline || valueID == CSSValueBlack;
case CSSPropertyApplePayButtonType: // plain | buy | set-up | donate
if (valueID == CSSValuePlain || valueID == CSSValueBuy || valueID == CSSValueSetUp || valueID == CSSValueDonate)
return true;
#if ENABLE(APPLE_PAY_SESSION_V4)
// check-out | book | subscribe
return valueID == CSSValueCheckOut || valueID == CSSValueBook || valueID == CSSValueSubscribe;
#else
return false;
#endif
#endif
case CSSPropertyWebkitNbspMode: // normal | space
return valueID == CSSValueNormal || valueID == CSSValueSpace;
case CSSPropertyWebkitTextZoom:
return valueID == CSSValueNormal || valueID == CSSValueReset;
#if PLATFORM(IOS_FAMILY)
// Apple specific property. These will never be standardized and is purely to
// support custom WebKit-based Apple applications.
case CSSPropertyWebkitTouchCallout:
return valueID == CSSValueDefault || valueID == CSSValueNone;
#endif
case CSSPropertyWebkitMarqueeDirection:
return valueID == CSSValueForwards || valueID == CSSValueBackwards || valueID == CSSValueAhead || valueID == CSSValueReverse || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueDown
|| valueID == CSSValueUp || valueID == CSSValueAuto;
case CSSPropertyWebkitMarqueeStyle:
return valueID == CSSValueNone || valueID == CSSValueSlide || valueID == CSSValueScroll || valueID == CSSValueAlternate;
case CSSPropertyFontVariantPosition: // normal | sub | super
return valueID == CSSValueNormal || valueID == CSSValueSub || valueID == CSSValueSuper;
case CSSPropertyFontVariantCaps: // normal | small-caps | all-small-caps | petite-caps | all-petite-caps | unicase | titling-caps
return valueID == CSSValueNormal || valueID == CSSValueSmallCaps || valueID == CSSValueAllSmallCaps || valueID == CSSValuePetiteCaps || valueID == CSSValueAllPetiteCaps || valueID == CSSValueUnicase || valueID == CSSValueTitlingCaps;
case CSSPropertyFontVariantAlternates: // We only support the normal and historical-forms values.
return valueID == CSSValueNormal || valueID == CSSValueHistoricalForms;
#if ENABLE(OVERFLOW_SCROLLING_TOUCH)
case CSSPropertyWebkitOverflowScrolling:
if (!context.legacyOverflowScrollingTouchEnabled)
return false;
return valueID == CSSValueAuto || valueID == CSSValueTouch;
#endif
#if ENABLE(VARIATION_FONTS)
case CSSPropertyFontOpticalSizing:
return valueID == CSSValueAuto || valueID == CSSValueNone;
#endif
default:
ASSERT_NOT_REACHED();
return false;
}
}
bool CSSParserFastPaths::isKeywordPropertyID(CSSPropertyID propertyId)
{
switch (propertyId) {
case CSSPropertyBorderBlockEndStyle:
case CSSPropertyBorderBlockStartStyle:
case CSSPropertyBorderBottomStyle:
case CSSPropertyBorderCollapse:
case CSSPropertyBorderInlineEndStyle:
case CSSPropertyBorderInlineStartStyle:
case CSSPropertyBorderLeftStyle:
case CSSPropertyBorderRightStyle:
case CSSPropertyBorderTopStyle:
case CSSPropertyBoxSizing:
case CSSPropertyBreakAfter:
case CSSPropertyBreakBefore:
case CSSPropertyBreakInside:
case CSSPropertyCaptionSide:
case CSSPropertyClear:
case CSSPropertyColumnFill:
case CSSPropertyWebkitColumnProgression:
case CSSPropertyColumnRuleStyle:
case CSSPropertyDirection:
case CSSPropertyDisplay:
case CSSPropertyEmptyCells:
case CSSPropertyFlexDirection:
case CSSPropertyFlexWrap:
case CSSPropertyFloat:
case CSSPropertyFontVariantAlternates:
case CSSPropertyFontVariantCaps:
case CSSPropertyFontVariantPosition:
case CSSPropertyImageRendering:
case CSSPropertyListStylePosition:
case CSSPropertyListStyleType:
case CSSPropertyObjectFit:
case CSSPropertyOutlineStyle:
case CSSPropertyOverflowWrap:
case CSSPropertyOverflowX:
case CSSPropertyOverflowY:
case CSSPropertyPointerEvents:
case CSSPropertyPosition:
case CSSPropertyResize:
case CSSPropertyTableLayout:
case CSSPropertyTextAlign:
case CSSPropertyTextOverflow:
case CSSPropertyTextRendering:
case CSSPropertyTextTransform:
case CSSPropertyTransformStyle:
case CSSPropertyUnicodeBidi:
case CSSPropertyVisibility:
case CSSPropertyWebkitAppearance:
case CSSPropertyWebkitBackfaceVisibility:
case CSSPropertyWebkitBorderFit:
case CSSPropertyWebkitBoxAlign:
case CSSPropertyWebkitBoxDirection:
case CSSPropertyWebkitBoxLines:
case CSSPropertyWebkitBoxOrient:
case CSSPropertyWebkitBoxPack:
case CSSPropertyWebkitColumnAxis:
case CSSPropertyWebkitFontKerning:
case CSSPropertyWebkitFontSmoothing:
case CSSPropertyWebkitHyphens:
case CSSPropertyWebkitLineAlign:
case CSSPropertyLineBreak:
case CSSPropertyWebkitLineSnap:
case CSSPropertyWebkitMarginAfterCollapse:
case CSSPropertyWebkitMarginBeforeCollapse:
case CSSPropertyWebkitMarginBottomCollapse:
case CSSPropertyWebkitMarginTopCollapse:
case CSSPropertyWebkitMarqueeDirection:
case CSSPropertyWebkitMarqueeStyle:
case CSSPropertyWebkitNbspMode:
case CSSPropertyWebkitPrintColorAdjust:
case CSSPropertyWebkitRtlOrdering:
case CSSPropertyWebkitRubyPosition:
case CSSPropertyWebkitTextCombine:
case CSSPropertyTextDecorationStyle:
case CSSPropertyWebkitTextOrientation:
case CSSPropertyWebkitTextSecurity:
case CSSPropertyWebkitTextZoom:
case CSSPropertyWebkitTransformStyle:
case CSSPropertyWebkitUserDrag:
case CSSPropertyWebkitUserModify:
case CSSPropertyWebkitUserSelect:
case CSSPropertyWhiteSpace:
case CSSPropertyWordBreak:
case CSSPropertyWordWrap:
// SVG CSS properties from SVG 1.1, Appendix N: Property Index.
case CSSPropertyAlignmentBaseline:
case CSSPropertyBufferedRendering:
case CSSPropertyClipRule:
case CSSPropertyColorInterpolation:
case CSSPropertyColorInterpolationFilters:
case CSSPropertyColorRendering:
case CSSPropertyDominantBaseline:
case CSSPropertyFillRule:
case CSSPropertyMaskType:
case CSSPropertyShapeRendering:
case CSSPropertyStrokeLinecap:
case CSSPropertyStrokeLinejoin:
case CSSPropertyTextAnchor:
case CSSPropertyVectorEffect:
case CSSPropertyWritingMode:
// FIXME-NEWPARSER: Treat all as a keyword property.
// case CSSPropertyAll:
// FIXME-NEWPARSER: Add the following unprefixed properties:
// case CSSPropertyBackfaceVisibility:
// case CSSPropertyFontKerning:
// case CSSPropertyHyphens:
// case CSSPropertyOverflowAnchor:
// case CSSPropertyScrollBehavior:
// case CSSPropertyScrollSnapType:
// case CSSPropertyTextAlignLast:
// case CSSPropertyTextCombineUpright:
// case CSSPropertyTextDecorationStyle:
// case CSSPropertyTextJustify:
// case CSSPropertyTextOrientation:
// case CSSPropertyUserSelect:
#if ENABLE(CSS_TRAILING_WORD)
case CSSPropertyAppleTrailingWord:
#endif
#if ENABLE(CSS_COMPOSITING)
case CSSPropertyIsolation:
case CSSPropertyMixBlendMode:
#endif
#if ENABLE(CSS_BOX_DECORATION_BREAK)
case CSSPropertyWebkitBoxDecorationBreak:
#endif
#if ENABLE(CURSOR_VISIBILITY)
case CSSPropertyWebkitCursorVisibility:
#endif
#if ENABLE(OVERFLOW_SCROLLING_TOUCH)
case CSSPropertyWebkitOverflowScrolling:
#endif
#if ENABLE(CSS3_TEXT)
case CSSPropertyWebkitTextAlignLast:
case CSSPropertyWebkitTextJustify:
#endif
#if PLATFORM(IOS_FAMILY)
// Apple specific property. This will never be standardized and is purely to
// support custom WebKit-based Apple applications.
case CSSPropertyWebkitTouchCallout:
#endif
#if ENABLE(APPLE_PAY)
case CSSPropertyApplePayButtonStyle:
case CSSPropertyApplePayButtonType:
#endif
#if ENABLE(VARIATION_FONTS)
case CSSPropertyFontOpticalSizing:
#endif
return true;
default:
return false;
}
}
static bool isUniversalKeyword(const String& string)
{
// These keywords can be used for all properties.
return equalLettersIgnoringASCIICase(string, "initial")
|| equalLettersIgnoringASCIICase(string, "inherit")
|| equalLettersIgnoringASCIICase(string, "unset")
|| equalLettersIgnoringASCIICase(string, "revert");
}
static RefPtr<CSSValue> parseKeywordValue(CSSPropertyID propertyId, const String& string, const CSSParserContext& context)
{
ASSERT(!string.isEmpty());
if (!CSSParserFastPaths::isKeywordPropertyID(propertyId)) {
// All properties accept the values of "initial" and "inherit".
if (!isUniversalKeyword(string))
return nullptr;
// Parse initial/inherit shorthands using the CSSPropertyParser.
if (shorthandForProperty(propertyId).length())
return nullptr;
// Descriptors do not support css wide keywords.
if (CSSProperty::isDescriptorOnly(propertyId))
return nullptr;
}
CSSValueID valueID = cssValueKeywordID(string);
if (!valueID)
return nullptr;
if (valueID == CSSValueInherit)
return CSSValuePool::singleton().createInheritedValue();
if (valueID == CSSValueInitial)
return CSSValuePool::singleton().createExplicitInitialValue();
if (valueID == CSSValueUnset)
return CSSValuePool::singleton().createUnsetValue();
if (valueID == CSSValueRevert)
return CSSValuePool::singleton().createRevertValue();
if (CSSParserFastPaths::isValidKeywordPropertyAndValue(propertyId, valueID, context))
return CSSPrimitiveValue::createIdentifier(valueID);
return nullptr;
}
template <typename CharType>
static bool parseTransformTranslateArguments(CharType*& pos, CharType* end, unsigned expectedCount, CSSFunctionValue* transformValue)
{
while (expectedCount) {
size_t delimiter = WTF::find(pos, end - pos, expectedCount == 1 ? ')' : ',');
if (delimiter == notFound)
return false;
unsigned argumentLength = static_cast<unsigned>(delimiter);
CSSPrimitiveValue::UnitType unit = CSSPrimitiveValue::UnitType::CSS_NUMBER;
double number;
if (!parseSimpleLength(pos, argumentLength, unit, number))
return false;
if (!number && unit == CSSPrimitiveValue::CSS_NUMBER)
unit = CSSPrimitiveValue::UnitType::CSS_PX;
if (unit == CSSPrimitiveValue::UnitType::CSS_NUMBER || (unit == CSSPrimitiveValue::UnitType::CSS_PERCENTAGE && (transformValue->name() == CSSValueTranslateZ || (transformValue->name() == CSSValueTranslate3d && expectedCount == 1))))
return false;
transformValue->append(CSSPrimitiveValue::create(number, unit));
pos += argumentLength + 1;
--expectedCount;
}
return true;
}
template <typename CharType>
static bool parseTransformAngleArgument(CharType*& pos, CharType* end, CSSFunctionValue* transformValue)
{
size_t delimiter = WTF::find(pos, end - pos, ')');
if (delimiter == notFound)
return false;
unsigned argumentLength = static_cast<unsigned>(delimiter);
CSSPrimitiveValue::UnitType unit = CSSPrimitiveValue::UnitType::CSS_NUMBER;
double number;
if (!parseSimpleAngle(pos, argumentLength, unit, number))
return false;
if (!number && unit == CSSPrimitiveValue::CSS_NUMBER)
unit = CSSPrimitiveValue::UnitType::CSS_DEG;
transformValue->append(CSSPrimitiveValue::create(number, unit));
pos += argumentLength + 1;
return true;
}
template <typename CharType>
static bool parseTransformNumberArguments(CharType*& pos, CharType* end, unsigned expectedCount, CSSFunctionValue* transformValue)
{
while (expectedCount) {
size_t delimiter = WTF::find(pos, end - pos, expectedCount == 1 ? ')' : ',');
if (delimiter == notFound)
return false;
unsigned argumentLength = static_cast<unsigned>(delimiter);
bool ok;
double number = charactersToDouble(pos, argumentLength, &ok);
if (!ok)
return false;
transformValue->append(CSSPrimitiveValue::create(number, CSSPrimitiveValue::UnitType::CSS_NUMBER));
pos += argumentLength + 1;
--expectedCount;
}
return true;
}
static const int kShortestValidTransformStringLength = 9; // "rotate(0)"
template <typename CharType>
static RefPtr<CSSFunctionValue> parseSimpleTransformValue(CharType*& pos, CharType* end)
{
if (end - pos < kShortestValidTransformStringLength)
return nullptr;
const bool isTranslate = toASCIILower(pos[0]) == 't'
&& toASCIILower(pos[1]) == 'r'
&& toASCIILower(pos[2]) == 'a'
&& toASCIILower(pos[3]) == 'n'
&& toASCIILower(pos[4]) == 's'
&& toASCIILower(pos[5]) == 'l'
&& toASCIILower(pos[6]) == 'a'
&& toASCIILower(pos[7]) == 't'
&& toASCIILower(pos[8]) == 'e';
if (isTranslate) {
CSSValueID transformType;
unsigned expectedArgumentCount = 1;
unsigned argumentStart = 11;
CharType c9 = toASCIILower(pos[9]);
if (c9 == 'x' && pos[10] == '(') {
transformType = CSSValueTranslateX;
} else if (c9 == 'y' && pos[10] == '(') {
transformType = CSSValueTranslateY;
} else if (c9 == 'z' && pos[10] == '(') {
transformType = CSSValueTranslateZ;
} else if (c9 == '(') {
transformType = CSSValueTranslate;
expectedArgumentCount = 2;
argumentStart = 10;
} else if (c9 == '3' && toASCIILower(pos[10]) == 'd' && pos[11] == '(') {
transformType = CSSValueTranslate3d;
expectedArgumentCount = 3;
argumentStart = 12;
} else
return nullptr;
pos += argumentStart;
RefPtr<CSSFunctionValue> transformValue = CSSFunctionValue::create(transformType);
if (!parseTransformTranslateArguments(pos, end, expectedArgumentCount, transformValue.get()))
return nullptr;
return transformValue;
}
const bool isMatrix3d = toASCIILower(pos[0]) == 'm'
&& toASCIILower(pos[1]) == 'a'
&& toASCIILower(pos[2]) == 't'
&& toASCIILower(pos[3]) == 'r'
&& toASCIILower(pos[4]) == 'i'
&& toASCIILower(pos[5]) == 'x'
&& pos[6] == '3'
&& toASCIILower(pos[7]) == 'd'
&& pos[8] == '(';
if (isMatrix3d) {
pos += 9;
RefPtr<CSSFunctionValue> transformValue = CSSFunctionValue::create(CSSValueMatrix3d);
if (!parseTransformNumberArguments(pos, end, 16, transformValue.get()))
return nullptr;
return transformValue;
}
const bool isScale3d = toASCIILower(pos[0]) == 's'
&& toASCIILower(pos[1]) == 'c'
&& toASCIILower(pos[2]) == 'a'
&& toASCIILower(pos[3]) == 'l'
&& toASCIILower(pos[4]) == 'e'
&& pos[5] == '3'
&& toASCIILower(pos[6]) == 'd'
&& pos[7] == '(';
if (isScale3d) {
pos += 8;
RefPtr<CSSFunctionValue> transformValue = CSSFunctionValue::create(CSSValueScale3d);
if (!parseTransformNumberArguments(pos, end, 3, transformValue.get()))
return nullptr;
return transformValue;
}
const bool isRotate = toASCIILower(pos[0]) == 'r'
&& toASCIILower(pos[1]) == 'o'
&& toASCIILower(pos[2]) == 't'
&& toASCIILower(pos[3]) == 'a'
&& toASCIILower(pos[4]) == 't'
&& toASCIILower(pos[5]) == 'e';
if (isRotate) {
CSSValueID transformType;
unsigned argumentStart = 7;
CharType c6 = toASCIILower(pos[6]);
if (c6 == '(') {
transformType = CSSValueRotate;
} else if (c6 == 'z' && pos[7] == '(') {
transformType = CSSValueRotateZ;
argumentStart = 8;
} else
return nullptr;
pos += argumentStart;
RefPtr<CSSFunctionValue> transformValue = CSSFunctionValue::create(transformType);
if (!parseTransformAngleArgument(pos, end, transformValue.get()))
return nullptr;
return transformValue;
}
return nullptr;
}
template <typename CharType>
static bool transformCanLikelyUseFastPath(const CharType* chars, unsigned length)
{
// Very fast scan that attempts to reject most transforms that couldn't
// take the fast path. This avoids doing the malloc and string->double
// conversions in parseSimpleTransformValue only to discard them when we
// run into a transform component we don't understand.
unsigned i = 0;
while (i < length) {
if (isCSSSpace(chars[i])) {
++i;
continue;
}
if (length - i < kShortestValidTransformStringLength)
return false;
switch (toASCIILower(chars[i])) {
case 't':
// translate, translateX, translateY, translateZ, translate3d.
if (toASCIILower(chars[i + 8]) != 'e')
return false;
i += 9;
break;
case 'm':
// matrix3d.
if (toASCIILower(chars[i + 7]) != 'd')
return false;
i += 8;
break;
case 's':
// scale3d.
if (toASCIILower(chars[i + 6]) != 'd')
return false;
i += 7;
break;
case 'r':
// rotate.
if (toASCIILower(chars[i + 5]) != 'e')
return false;
i += 6;
// rotateZ
if (toASCIILower(chars[i]) == 'z')
++i;
break;
default:
return false;
}
size_t argumentsEnd = WTF::find(chars, length, ')', i);
if (argumentsEnd == notFound)
return false;
// Advance to the end of the arguments.
i = argumentsEnd + 1;
}
return i == length;
}
template <typename CharType>
static RefPtr<CSSValueList> parseSimpleTransformList(const CharType* chars, unsigned length)
{
if (!transformCanLikelyUseFastPath(chars, length))
return nullptr;
const CharType*& pos = chars;
const CharType* end = chars + length;
RefPtr<CSSValueList> transformList;
while (pos < end) {
while (pos < end && isCSSSpace(*pos))
++pos;
if (pos >= end)
break;
RefPtr<CSSFunctionValue> transformValue = parseSimpleTransformValue(pos, end);
if (!transformValue)
return nullptr;
if (!transformList)
transformList = CSSValueList::createSpaceSeparated();
transformList->append(*transformValue);
}
return transformList;
}
static RefPtr<CSSValue> parseSimpleTransform(CSSPropertyID propertyID, const String& string)
{
ASSERT(!string.isEmpty());
if (propertyID != CSSPropertyTransform)
return nullptr;
if (string.is8Bit())
return parseSimpleTransformList(string.characters8(), string.length());
return parseSimpleTransformList(string.characters16(), string.length());
}
static RefPtr<CSSValue> parseCaretColor(const String& string, CSSParserMode parserMode)
{
ASSERT(!string.isEmpty());
CSSValueID valueID = cssValueKeywordID(string);
if (valueID == CSSValueAuto)
return CSSValuePool::singleton().createIdentifierValue(valueID);
return CSSParserFastPaths::parseColor(string, parserMode);
}
RefPtr<CSSValue> CSSParserFastPaths::maybeParseValue(CSSPropertyID propertyID, const String& string, const CSSParserContext& context)
{
if (auto result = parseSimpleLengthValue(propertyID, string, context.mode))
return result;
if (propertyID == CSSPropertyCaretColor)
return parseCaretColor(string, context.mode);
if (isColorPropertyID(propertyID))
return parseColor(string, context.mode);
if (auto result = parseKeywordValue(propertyID, string, context))
return result;
return parseSimpleTransform(propertyID, string);
}
} // namespace WebCore