| // Copyright 2015 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "core/css/parser/CSSPropertyParser.h" |
| |
| #include "core/StylePropertyShorthand.h" |
| #include "core/css/CSSBasicShapeValues.h" |
| #include "core/css/CSSBorderImage.h" |
| #include "core/css/CSSContentDistributionValue.h" |
| #include "core/css/CSSCounterValue.h" |
| #include "core/css/CSSCursorImageValue.h" |
| #include "core/css/CSSCustomIdentValue.h" |
| #include "core/css/CSSFontFaceSrcValue.h" |
| #include "core/css/CSSFontFamilyValue.h" |
| #include "core/css/CSSFontFeatureValue.h" |
| #include "core/css/CSSFunctionValue.h" |
| #include "core/css/CSSGridAutoRepeatValue.h" |
| #include "core/css/CSSGridLineNamesValue.h" |
| #include "core/css/CSSGridTemplateAreasValue.h" |
| #include "core/css/CSSIdentifierValue.h" |
| #include "core/css/CSSInheritedValue.h" |
| #include "core/css/CSSInitialValue.h" |
| #include "core/css/CSSPathValue.h" |
| #include "core/css/CSSPendingSubstitutionValue.h" |
| #include "core/css/CSSPrimitiveValueMappings.h" |
| #include "core/css/CSSQuadValue.h" |
| #include "core/css/CSSReflectValue.h" |
| #include "core/css/CSSShadowValue.h" |
| #include "core/css/CSSStringValue.h" |
| #include "core/css/CSSTimingFunctionValue.h" |
| #include "core/css/CSSURIValue.h" |
| #include "core/css/CSSUnicodeRangeValue.h" |
| #include "core/css/CSSUnsetValue.h" |
| #include "core/css/CSSValuePair.h" |
| #include "core/css/CSSVariableReferenceValue.h" |
| #include "core/css/FontFace.h" |
| #include "core/css/HashTools.h" |
| #include "core/css/parser/CSSParserFastPaths.h" |
| #include "core/css/parser/CSSParserIdioms.h" |
| #include "core/css/parser/CSSPropertyParserHelpers.h" |
| #include "core/css/parser/CSSVariableParser.h" |
| #include "core/frame/UseCounter.h" |
| #include "core/layout/LayoutTheme.h" |
| #include "core/svg/SVGPathUtilities.h" |
| #include "wtf/text/StringBuilder.h" |
| #include <memory> |
| |
| namespace blink { |
| |
| using namespace CSSPropertyParserHelpers; |
| |
| CSSPropertyParser::CSSPropertyParser( |
| const CSSParserTokenRange& range, |
| const CSSParserContext& context, |
| HeapVector<CSSProperty, 256>* parsedProperties) |
| : m_range(range), m_context(context), m_parsedProperties(parsedProperties) { |
| m_range.consumeWhitespace(); |
| } |
| |
| void CSSPropertyParser::addProperty(CSSPropertyID property, |
| CSSPropertyID currentShorthand, |
| const CSSValue& value, |
| bool important, |
| bool implicit) { |
| ASSERT(!isPropertyAlias(property)); |
| |
| int shorthandIndex = 0; |
| bool setFromShorthand = false; |
| |
| if (currentShorthand) { |
| Vector<StylePropertyShorthand, 4> shorthands; |
| getMatchingShorthandsForLonghand(property, &shorthands); |
| setFromShorthand = true; |
| if (shorthands.size() > 1) |
| shorthandIndex = |
| indexOfShorthandForLonghand(currentShorthand, shorthands); |
| } |
| |
| m_parsedProperties->append(CSSProperty( |
| property, value, important, setFromShorthand, shorthandIndex, implicit)); |
| } |
| |
| void CSSPropertyParser::addExpandedPropertyForValue(CSSPropertyID property, |
| const CSSValue& value, |
| bool important) { |
| const StylePropertyShorthand& shorthand = shorthandForProperty(property); |
| unsigned shorthandLength = shorthand.length(); |
| ASSERT(shorthandLength); |
| const CSSPropertyID* longhands = shorthand.properties(); |
| for (unsigned i = 0; i < shorthandLength; ++i) |
| addProperty(longhands[i], property, value, important); |
| } |
| |
| bool CSSPropertyParser::parseValue( |
| CSSPropertyID unresolvedProperty, |
| bool important, |
| const CSSParserTokenRange& range, |
| const CSSParserContext& context, |
| HeapVector<CSSProperty, 256>& parsedProperties, |
| StyleRule::RuleType ruleType) { |
| int parsedPropertiesSize = parsedProperties.size(); |
| |
| CSSPropertyParser parser(range, context, &parsedProperties); |
| CSSPropertyID resolvedProperty = resolveCSSPropertyID(unresolvedProperty); |
| bool parseSuccess; |
| |
| if (ruleType == StyleRule::Viewport) { |
| parseSuccess = (RuntimeEnabledFeatures::cssViewportEnabled() || |
| isUASheetBehavior(context.mode())) && |
| parser.parseViewportDescriptor(resolvedProperty, important); |
| } else if (ruleType == StyleRule::FontFace) { |
| parseSuccess = parser.parseFontFaceDescriptor(resolvedProperty); |
| } else { |
| parseSuccess = parser.parseValueStart(unresolvedProperty, important); |
| } |
| |
| // This doesn't count UA style sheets |
| if (parseSuccess && context.useCounter()) |
| context.useCounter()->count(context.mode(), unresolvedProperty); |
| |
| if (!parseSuccess) |
| parsedProperties.shrink(parsedPropertiesSize); |
| |
| return parseSuccess; |
| } |
| |
| const CSSValue* CSSPropertyParser::parseSingleValue( |
| CSSPropertyID property, |
| const CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| CSSPropertyParser parser(range, context, nullptr); |
| const CSSValue* value = parser.parseSingleValue(property); |
| if (!value || !parser.m_range.atEnd()) |
| return nullptr; |
| return value; |
| } |
| |
| bool CSSPropertyParser::parseValueStart(CSSPropertyID unresolvedProperty, |
| bool important) { |
| if (consumeCSSWideKeyword(unresolvedProperty, important)) |
| return true; |
| |
| CSSParserTokenRange originalRange = m_range; |
| CSSPropertyID propertyId = resolveCSSPropertyID(unresolvedProperty); |
| bool isShorthand = isShorthandProperty(propertyId); |
| |
| if (isShorthand) { |
| // Variable references will fail to parse here and will fall out to the |
| // variable ref parser below. |
| if (parseShorthand(unresolvedProperty, important)) |
| return true; |
| } else { |
| if (const CSSValue* parsedValue = parseSingleValue(unresolvedProperty)) { |
| if (m_range.atEnd()) { |
| addProperty(propertyId, CSSPropertyInvalid, *parsedValue, important); |
| return true; |
| } |
| } |
| } |
| |
| if (CSSVariableParser::containsValidVariableReferences(originalRange)) { |
| bool isAnimationTainted = false; |
| CSSVariableReferenceValue* variable = CSSVariableReferenceValue::create( |
| CSSVariableData::create(originalRange, isAnimationTainted, true)); |
| |
| if (isShorthand) { |
| const CSSPendingSubstitutionValue& pendingValue = |
| *CSSPendingSubstitutionValue::create(propertyId, variable); |
| addExpandedPropertyForValue(propertyId, pendingValue, important); |
| } else { |
| addProperty(propertyId, CSSPropertyInvalid, *variable, important); |
| } |
| return true; |
| } |
| |
| return false; |
| } |
| |
| template <typename CharacterType> |
| static CSSPropertyID unresolvedCSSPropertyID(const CharacterType* propertyName, |
| unsigned length) { |
| if (length == 0) |
| return CSSPropertyInvalid; |
| if (length >= 2 && propertyName[0] == '-' && propertyName[1] == '-') |
| return CSSPropertyVariable; |
| if (length > maxCSSPropertyNameLength) |
| return CSSPropertyInvalid; |
| |
| char buffer[maxCSSPropertyNameLength + 1]; // 1 for null character |
| |
| for (unsigned i = 0; i != length; ++i) { |
| CharacterType c = propertyName[i]; |
| if (c == 0 || c >= 0x7F) |
| return CSSPropertyInvalid; // illegal character |
| buffer[i] = toASCIILower(c); |
| } |
| buffer[length] = '\0'; |
| |
| const char* name = buffer; |
| const Property* hashTableEntry = findProperty(name, length); |
| if (!hashTableEntry) |
| return CSSPropertyInvalid; |
| CSSPropertyID property = static_cast<CSSPropertyID>(hashTableEntry->id); |
| if (!CSSPropertyMetadata::isEnabledProperty(property)) |
| return CSSPropertyInvalid; |
| return property; |
| } |
| |
| CSSPropertyID unresolvedCSSPropertyID(const String& string) { |
| unsigned length = string.length(); |
| return string.is8Bit() |
| ? unresolvedCSSPropertyID(string.characters8(), length) |
| : unresolvedCSSPropertyID(string.characters16(), length); |
| } |
| |
| CSSPropertyID unresolvedCSSPropertyID(StringView string) { |
| unsigned length = string.length(); |
| return string.is8Bit() |
| ? unresolvedCSSPropertyID(string.characters8(), length) |
| : unresolvedCSSPropertyID(string.characters16(), length); |
| } |
| |
| template <typename CharacterType> |
| static CSSValueID cssValueKeywordID(const CharacterType* valueKeyword, |
| unsigned length) { |
| char buffer[maxCSSValueKeywordLength + 1]; // 1 for null character |
| |
| for (unsigned i = 0; i != length; ++i) { |
| CharacterType c = valueKeyword[i]; |
| if (c == 0 || c >= 0x7F) |
| return CSSValueInvalid; // illegal character |
| buffer[i] = WTF::toASCIILower(c); |
| } |
| buffer[length] = '\0'; |
| |
| const Value* hashTableEntry = findValue(buffer, length); |
| return hashTableEntry ? static_cast<CSSValueID>(hashTableEntry->id) |
| : CSSValueInvalid; |
| } |
| |
| CSSValueID cssValueKeywordID(StringView string) { |
| unsigned length = string.length(); |
| if (!length) |
| return CSSValueInvalid; |
| if (length > maxCSSValueKeywordLength) |
| return CSSValueInvalid; |
| |
| return string.is8Bit() ? cssValueKeywordID(string.characters8(), length) |
| : cssValueKeywordID(string.characters16(), length); |
| } |
| |
| bool CSSPropertyParser::consumeCSSWideKeyword(CSSPropertyID unresolvedProperty, |
| bool important) { |
| CSSParserTokenRange rangeCopy = m_range; |
| CSSValueID id = rangeCopy.consumeIncludingWhitespace().id(); |
| if (!rangeCopy.atEnd()) |
| return false; |
| |
| CSSValue* value = nullptr; |
| if (id == CSSValueInitial) |
| value = CSSInitialValue::create(); |
| else if (id == CSSValueInherit) |
| value = CSSInheritedValue::create(); |
| else if (id == CSSValueUnset) |
| value = CSSUnsetValue::create(); |
| else |
| return false; |
| |
| CSSPropertyID property = resolveCSSPropertyID(unresolvedProperty); |
| const StylePropertyShorthand& shorthand = shorthandForProperty(property); |
| if (!shorthand.length()) { |
| if (CSSPropertyMetadata::isDescriptorOnly(unresolvedProperty)) |
| return false; |
| addProperty(property, CSSPropertyInvalid, *value, important); |
| } else { |
| addExpandedPropertyForValue(property, *value, important); |
| } |
| m_range = rangeCopy; |
| return true; |
| } |
| |
| static CSSValueList* consumeTransformOrigin(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode, |
| UnitlessQuirk unitless) { |
| CSSValue* resultX = nullptr; |
| CSSValue* resultY = nullptr; |
| if (consumeOneOrTwoValuedPosition(range, cssParserMode, unitless, resultX, |
| resultY)) { |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| list->append(*resultX); |
| list->append(*resultY); |
| CSSValue* resultZ = consumeLength(range, cssParserMode, ValueRangeAll); |
| if (!resultZ) |
| resultZ = |
| CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::Pixels); |
| list->append(*resultZ); |
| return list; |
| } |
| return nullptr; |
| } |
| |
| // Methods for consuming non-shorthand properties starts here. |
| static CSSValue* consumeWillChange(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueAuto) |
| return consumeIdent(range); |
| |
| CSSValueList* values = CSSValueList::createCommaSeparated(); |
| // Every comma-separated list of identifiers is a valid will-change value, |
| // unless the list includes an explicitly disallowed identifier. |
| while (true) { |
| if (range.peek().type() != IdentToken) |
| return nullptr; |
| CSSPropertyID unresolvedProperty = |
| unresolvedCSSPropertyID(range.peek().value()); |
| if (unresolvedProperty != CSSPropertyInvalid && |
| unresolvedProperty != CSSPropertyVariable) { |
| ASSERT(CSSPropertyMetadata::isEnabledProperty(unresolvedProperty)); |
| // Now "all" is used by both CSSValue and CSSPropertyValue. |
| // Need to return nullptr when currentValue is CSSPropertyAll. |
| if (unresolvedProperty == CSSPropertyWillChange || |
| unresolvedProperty == CSSPropertyAll) |
| return nullptr; |
| values->append(*CSSCustomIdentValue::create(unresolvedProperty)); |
| range.consumeIncludingWhitespace(); |
| } else { |
| switch (range.peek().id()) { |
| case CSSValueNone: |
| case CSSValueAll: |
| case CSSValueAuto: |
| case CSSValueDefault: |
| case CSSValueInitial: |
| case CSSValueInherit: |
| return nullptr; |
| case CSSValueContents: |
| case CSSValueScrollPosition: |
| values->append(*consumeIdent(range)); |
| break; |
| default: |
| range.consumeIncludingWhitespace(); |
| break; |
| } |
| } |
| |
| if (range.atEnd()) |
| break; |
| if (!consumeCommaIncludingWhitespace(range)) |
| return nullptr; |
| } |
| |
| return values; |
| } |
| |
| static CSSFontFeatureValue* consumeFontFeatureTag(CSSParserTokenRange& range) { |
| // Feature tag name consists of 4-letter characters. |
| static const unsigned tagNameLength = 4; |
| |
| const CSSParserToken& token = range.consumeIncludingWhitespace(); |
| // Feature tag name comes first |
| if (token.type() != StringToken) |
| return nullptr; |
| if (token.value().length() != tagNameLength) |
| return nullptr; |
| AtomicString tag = token.value().toAtomicString(); |
| for (unsigned i = 0; i < tagNameLength; ++i) { |
| // Limits the range of characters to 0x20-0x7E, following the tag name rules |
| // defiend in the OpenType specification. |
| UChar character = tag[i]; |
| if (character < 0x20 || character > 0x7E) |
| return nullptr; |
| } |
| |
| int tagValue = 1; |
| // Feature tag values could follow: <integer> | on | off |
| if (range.peek().type() == NumberToken && |
| range.peek().numericValueType() == IntegerValueType && |
| range.peek().numericValue() >= 0) { |
| tagValue = clampTo<int>(range.consumeIncludingWhitespace().numericValue()); |
| if (tagValue < 0) |
| return nullptr; |
| } else if (range.peek().id() == CSSValueOn || |
| range.peek().id() == CSSValueOff) { |
| tagValue = range.consumeIncludingWhitespace().id() == CSSValueOn; |
| } |
| return CSSFontFeatureValue::create(tag, tagValue); |
| } |
| |
| static CSSValue* consumeFontFeatureSettings(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueNormal) |
| return consumeIdent(range); |
| CSSValueList* settings = CSSValueList::createCommaSeparated(); |
| do { |
| CSSFontFeatureValue* fontFeatureValue = consumeFontFeatureTag(range); |
| if (!fontFeatureValue) |
| return nullptr; |
| settings->append(*fontFeatureValue); |
| } while (consumeCommaIncludingWhitespace(range)); |
| return settings; |
| } |
| |
| static CSSValue* consumePage(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueAuto) |
| return consumeIdent(range); |
| return consumeCustomIdent(range); |
| } |
| |
| static CSSValue* consumeQuotes(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| CSSValueList* values = CSSValueList::createSpaceSeparated(); |
| while (!range.atEnd()) { |
| CSSStringValue* parsedValue = consumeString(range); |
| if (!parsedValue) |
| return nullptr; |
| values->append(*parsedValue); |
| } |
| if (values->length() && values->length() % 2 == 0) |
| return values; |
| return nullptr; |
| } |
| |
| static CSSValue* consumeWebkitHighlight(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| return consumeString(range); |
| } |
| |
| class FontVariantLigaturesParser { |
| STACK_ALLOCATED(); |
| |
| public: |
| FontVariantLigaturesParser() |
| : m_sawCommonLigaturesValue(false), |
| m_sawDiscretionaryLigaturesValue(false), |
| m_sawHistoricalLigaturesValue(false), |
| m_sawContextualLigaturesValue(false), |
| m_result(CSSValueList::createSpaceSeparated()) {} |
| |
| enum class ParseResult { ConsumedValue, DisallowedValue, UnknownValue }; |
| |
| ParseResult consumeLigature(CSSParserTokenRange& range) { |
| CSSValueID valueID = range.peek().id(); |
| switch (valueID) { |
| case CSSValueNoCommonLigatures: |
| case CSSValueCommonLigatures: |
| if (m_sawCommonLigaturesValue) |
| return ParseResult::DisallowedValue; |
| m_sawCommonLigaturesValue = true; |
| break; |
| case CSSValueNoDiscretionaryLigatures: |
| case CSSValueDiscretionaryLigatures: |
| if (m_sawDiscretionaryLigaturesValue) |
| return ParseResult::DisallowedValue; |
| m_sawDiscretionaryLigaturesValue = true; |
| break; |
| case CSSValueNoHistoricalLigatures: |
| case CSSValueHistoricalLigatures: |
| if (m_sawHistoricalLigaturesValue) |
| return ParseResult::DisallowedValue; |
| m_sawHistoricalLigaturesValue = true; |
| break; |
| case CSSValueNoContextual: |
| case CSSValueContextual: |
| if (m_sawContextualLigaturesValue) |
| return ParseResult::DisallowedValue; |
| m_sawContextualLigaturesValue = true; |
| break; |
| default: |
| return ParseResult::UnknownValue; |
| } |
| m_result->append(*consumeIdent(range)); |
| return ParseResult::ConsumedValue; |
| } |
| |
| CSSValue* finalizeValue() { |
| if (!m_result->length()) |
| return CSSIdentifierValue::create(CSSValueNormal); |
| return m_result.release(); |
| } |
| |
| private: |
| bool m_sawCommonLigaturesValue; |
| bool m_sawDiscretionaryLigaturesValue; |
| bool m_sawHistoricalLigaturesValue; |
| bool m_sawContextualLigaturesValue; |
| Member<CSSValueList> m_result; |
| }; |
| |
| static CSSValue* consumeFontVariantLigatures(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueNormal || range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| |
| FontVariantLigaturesParser ligaturesParser; |
| do { |
| if (ligaturesParser.consumeLigature(range) != |
| FontVariantLigaturesParser::ParseResult::ConsumedValue) |
| return nullptr; |
| } while (!range.atEnd()); |
| |
| return ligaturesParser.finalizeValue(); |
| } |
| |
| static CSSIdentifierValue* consumeFontVariantCaps(CSSParserTokenRange& range) { |
| return consumeIdent<CSSValueNormal, CSSValueSmallCaps, CSSValueAllSmallCaps, |
| CSSValuePetiteCaps, CSSValueAllPetiteCaps, |
| CSSValueUnicase, CSSValueTitlingCaps>(range); |
| } |
| |
| class FontVariantNumericParser { |
| STACK_ALLOCATED(); |
| |
| public: |
| FontVariantNumericParser() |
| : m_sawNumericFigureValue(false), |
| m_sawNumericSpacingValue(false), |
| m_sawNumericFractionValue(false), |
| m_sawOrdinalValue(false), |
| m_sawSlashedZeroValue(false), |
| m_result(CSSValueList::createSpaceSeparated()) {} |
| |
| enum class ParseResult { ConsumedValue, DisallowedValue, UnknownValue }; |
| |
| ParseResult consumeNumeric(CSSParserTokenRange& range) { |
| CSSValueID valueID = range.peek().id(); |
| switch (valueID) { |
| case CSSValueLiningNums: |
| case CSSValueOldstyleNums: |
| if (m_sawNumericFigureValue) |
| return ParseResult::DisallowedValue; |
| m_sawNumericFigureValue = true; |
| break; |
| case CSSValueProportionalNums: |
| case CSSValueTabularNums: |
| if (m_sawNumericSpacingValue) |
| return ParseResult::DisallowedValue; |
| m_sawNumericSpacingValue = true; |
| break; |
| case CSSValueDiagonalFractions: |
| case CSSValueStackedFractions: |
| if (m_sawNumericFractionValue) |
| return ParseResult::DisallowedValue; |
| m_sawNumericFractionValue = true; |
| break; |
| case CSSValueOrdinal: |
| if (m_sawOrdinalValue) |
| return ParseResult::DisallowedValue; |
| m_sawOrdinalValue = true; |
| break; |
| case CSSValueSlashedZero: |
| if (m_sawSlashedZeroValue) |
| return ParseResult::DisallowedValue; |
| m_sawSlashedZeroValue = true; |
| break; |
| default: |
| return ParseResult::UnknownValue; |
| } |
| m_result->append(*consumeIdent(range)); |
| return ParseResult::ConsumedValue; |
| } |
| |
| CSSValue* finalizeValue() { |
| if (!m_result->length()) |
| return CSSIdentifierValue::create(CSSValueNormal); |
| return m_result.release(); |
| } |
| |
| private: |
| bool m_sawNumericFigureValue; |
| bool m_sawNumericSpacingValue; |
| bool m_sawNumericFractionValue; |
| bool m_sawOrdinalValue; |
| bool m_sawSlashedZeroValue; |
| Member<CSSValueList> m_result; |
| }; |
| |
| static CSSValue* consumeFontVariantNumeric(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueNormal) |
| return consumeIdent(range); |
| |
| FontVariantNumericParser numericParser; |
| do { |
| if (numericParser.consumeNumeric(range) != |
| FontVariantNumericParser::ParseResult::ConsumedValue) |
| return nullptr; |
| } while (!range.atEnd()); |
| |
| return numericParser.finalizeValue(); |
| } |
| |
| static CSSIdentifierValue* consumeFontVariantCSS21(CSSParserTokenRange& range) { |
| return consumeIdent<CSSValueNormal, CSSValueSmallCaps>(range); |
| } |
| |
| static CSSValue* consumeFontVariantList(CSSParserTokenRange& range) { |
| CSSValueList* values = CSSValueList::createCommaSeparated(); |
| do { |
| if (range.peek().id() == CSSValueAll) { |
| // FIXME: CSSPropertyParser::parseFontVariant() implements |
| // the old css3 draft: |
| // http://www.w3.org/TR/2002/WD-css3-webfonts-20020802/#font-variant |
| // 'all' is only allowed in @font-face and with no other values. |
| if (values->length()) |
| return nullptr; |
| return consumeIdent(range); |
| } |
| CSSIdentifierValue* fontVariant = consumeFontVariantCSS21(range); |
| if (fontVariant) |
| values->append(*fontVariant); |
| } while (consumeCommaIncludingWhitespace(range)); |
| |
| if (values->length()) |
| return values; |
| |
| return nullptr; |
| } |
| |
| static CSSIdentifierValue* consumeFontWeight(CSSParserTokenRange& range) { |
| const CSSParserToken& token = range.peek(); |
| if (token.id() >= CSSValueNormal && token.id() <= CSSValueLighter) |
| return consumeIdent(range); |
| if (token.type() != NumberToken || |
| token.numericValueType() != IntegerValueType) |
| return nullptr; |
| int weight = static_cast<int>(token.numericValue()); |
| if ((weight % 100) || weight < 100 || weight > 900) |
| return nullptr; |
| range.consumeIncludingWhitespace(); |
| return CSSIdentifierValue::create( |
| static_cast<CSSValueID>(CSSValue100 + weight / 100 - 1)); |
| } |
| |
| static String concatenateFamilyName(CSSParserTokenRange& range) { |
| StringBuilder builder; |
| bool addedSpace = false; |
| const CSSParserToken& firstToken = range.peek(); |
| while (range.peek().type() == IdentToken) { |
| if (!builder.isEmpty()) { |
| builder.append(' '); |
| addedSpace = true; |
| } |
| builder.append(range.consumeIncludingWhitespace().value()); |
| } |
| if (!addedSpace && isCSSWideKeyword(firstToken.value())) |
| return String(); |
| return builder.toString(); |
| } |
| |
| static CSSValue* consumeFamilyName(CSSParserTokenRange& range) { |
| if (range.peek().type() == StringToken) |
| return CSSFontFamilyValue::create( |
| range.consumeIncludingWhitespace().value().toString()); |
| if (range.peek().type() != IdentToken) |
| return nullptr; |
| String familyName = concatenateFamilyName(range); |
| if (familyName.isNull()) |
| return nullptr; |
| return CSSFontFamilyValue::create(familyName); |
| } |
| |
| static CSSValue* consumeGenericFamily(CSSParserTokenRange& range) { |
| return consumeIdentRange(range, CSSValueSerif, CSSValueWebkitBody); |
| } |
| |
| static CSSValueList* consumeFontFamily(CSSParserTokenRange& range) { |
| CSSValueList* list = CSSValueList::createCommaSeparated(); |
| do { |
| CSSValue* parsedValue = consumeGenericFamily(range); |
| if (parsedValue) { |
| list->append(*parsedValue); |
| } else { |
| parsedValue = consumeFamilyName(range); |
| if (parsedValue) { |
| list->append(*parsedValue); |
| } else { |
| return nullptr; |
| } |
| } |
| } while (consumeCommaIncludingWhitespace(range)); |
| return list; |
| } |
| |
| static CSSValue* consumeSpacing(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| if (range.peek().id() == CSSValueNormal) |
| return consumeIdent(range); |
| // TODO(timloh): allow <percentage>s in word-spacing. |
| return consumeLength(range, cssParserMode, ValueRangeAll, |
| UnitlessQuirk::Allow); |
| } |
| |
| static CSSValue* consumeTabSize(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| CSSPrimitiveValue* parsedValue = consumeInteger(range, 0); |
| if (parsedValue) |
| return parsedValue; |
| return consumeLength(range, cssParserMode, ValueRangeNonNegative); |
| } |
| |
| static CSSValue* consumeTextSizeAdjust(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| if (range.peek().id() == CSSValueAuto) |
| return consumeIdent(range); |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| return consumePercent(range, ValueRangeNonNegative); |
| } |
| |
| static CSSValue* consumeFontSize( |
| CSSParserTokenRange& range, |
| CSSParserMode cssParserMode, |
| UnitlessQuirk unitless = UnitlessQuirk::Forbid) { |
| if (range.peek().id() >= CSSValueXxSmall && |
| range.peek().id() <= CSSValueLarger) |
| return consumeIdent(range); |
| return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, |
| unitless); |
| } |
| |
| static CSSValue* consumeLineHeight(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| if (range.peek().id() == CSSValueNormal) |
| return consumeIdent(range); |
| |
| CSSPrimitiveValue* lineHeight = consumeNumber(range, ValueRangeNonNegative); |
| if (lineHeight) |
| return lineHeight; |
| return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative); |
| } |
| |
| static CSSValueList* consumeRotation(CSSParserTokenRange& range) { |
| ASSERT(RuntimeEnabledFeatures::cssIndependentTransformPropertiesEnabled()); |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| |
| CSSValue* rotation = consumeAngle(range); |
| if (!rotation) |
| return nullptr; |
| list->append(*rotation); |
| |
| if (range.atEnd()) |
| return list; |
| |
| for (unsigned i = 0; i < 3; i++) { // 3 dimensions of rotation |
| CSSValue* dimension = consumeNumber(range, ValueRangeAll); |
| if (!dimension) |
| return nullptr; |
| list->append(*dimension); |
| } |
| |
| return list; |
| } |
| |
| static CSSValueList* consumeScale(CSSParserTokenRange& range) { |
| ASSERT(RuntimeEnabledFeatures::cssIndependentTransformPropertiesEnabled()); |
| |
| CSSValue* scale = consumeNumber(range, ValueRangeAll); |
| if (!scale) |
| return nullptr; |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| list->append(*scale); |
| scale = consumeNumber(range, ValueRangeAll); |
| if (scale) { |
| list->append(*scale); |
| scale = consumeNumber(range, ValueRangeAll); |
| if (scale) |
| list->append(*scale); |
| } |
| |
| return list; |
| } |
| |
| static CSSValueList* consumeTranslate(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| ASSERT(RuntimeEnabledFeatures::cssIndependentTransformPropertiesEnabled()); |
| CSSValue* translate = |
| consumeLengthOrPercent(range, cssParserMode, ValueRangeAll); |
| if (!translate) |
| return nullptr; |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| list->append(*translate); |
| translate = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll); |
| if (translate) { |
| list->append(*translate); |
| translate = consumeLength(range, cssParserMode, ValueRangeAll); |
| if (translate) |
| list->append(*translate); |
| } |
| |
| return list; |
| } |
| |
| static CSSValue* consumeCounter(CSSParserTokenRange& range, int defaultValue) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| do { |
| CSSCustomIdentValue* counterName = consumeCustomIdent(range); |
| if (!counterName) |
| return nullptr; |
| int i = defaultValue; |
| if (CSSPrimitiveValue* counterValue = consumeInteger(range)) |
| i = clampTo<int>(counterValue->getDoubleValue()); |
| list->append(*CSSValuePair::create( |
| counterName, |
| CSSPrimitiveValue::create(i, CSSPrimitiveValue::UnitType::Integer), |
| CSSValuePair::DropIdenticalValues)); |
| } while (!range.atEnd()); |
| return list; |
| } |
| |
| static CSSValue* consumePageSize(CSSParserTokenRange& range) { |
| return consumeIdent<CSSValueA3, CSSValueA4, CSSValueA5, CSSValueB4, |
| CSSValueB5, CSSValueLedger, CSSValueLegal, |
| CSSValueLetter>(range); |
| } |
| |
| static CSSValueList* consumeSize(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| CSSValueList* result = CSSValueList::createSpaceSeparated(); |
| |
| if (range.peek().id() == CSSValueAuto) { |
| result->append(*consumeIdent(range)); |
| return result; |
| } |
| |
| if (CSSValue* width = |
| consumeLength(range, cssParserMode, ValueRangeNonNegative)) { |
| CSSValue* height = |
| consumeLength(range, cssParserMode, ValueRangeNonNegative); |
| result->append(*width); |
| if (height) |
| result->append(*height); |
| return result; |
| } |
| |
| CSSValue* pageSize = consumePageSize(range); |
| CSSValue* orientation = |
| consumeIdent<CSSValuePortrait, CSSValueLandscape>(range); |
| if (!pageSize) |
| pageSize = consumePageSize(range); |
| |
| if (!orientation && !pageSize) |
| return nullptr; |
| if (pageSize) |
| result->append(*pageSize); |
| if (orientation) |
| result->append(*orientation); |
| return result; |
| } |
| |
| static CSSValue* consumeSnapHeight(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| CSSPrimitiveValue* unit = |
| consumeLength(range, cssParserMode, ValueRangeNonNegative); |
| if (!unit) |
| return nullptr; |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| list->append(*unit); |
| |
| if (CSSPrimitiveValue* position = consumePositiveInteger(range)) { |
| if (position->getIntValue() > 100) |
| return nullptr; |
| list->append(*position); |
| } |
| |
| return list; |
| } |
| |
| static CSSValue* consumeTextIndent(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| // [ <length> | <percentage> ] && hanging? && each-line? |
| // Keywords only allowed when css3Text is enabled. |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| |
| bool hasLengthOrPercentage = false; |
| bool hasEachLine = false; |
| bool hasHanging = false; |
| |
| do { |
| if (!hasLengthOrPercentage) { |
| if (CSSValue* textIndent = consumeLengthOrPercent( |
| range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow)) { |
| list->append(*textIndent); |
| hasLengthOrPercentage = true; |
| continue; |
| } |
| } |
| |
| if (RuntimeEnabledFeatures::css3TextEnabled()) { |
| CSSValueID id = range.peek().id(); |
| if (!hasEachLine && id == CSSValueEachLine) { |
| list->append(*consumeIdent(range)); |
| hasEachLine = true; |
| continue; |
| } |
| if (!hasHanging && id == CSSValueHanging) { |
| list->append(*consumeIdent(range)); |
| hasHanging = true; |
| continue; |
| } |
| } |
| return nullptr; |
| } while (!range.atEnd()); |
| |
| if (!hasLengthOrPercentage) |
| return nullptr; |
| |
| return list; |
| } |
| |
| static bool validWidthOrHeightKeyword(CSSValueID id, |
| const CSSParserContext& context) { |
| if (id == CSSValueWebkitMinContent || id == CSSValueWebkitMaxContent || |
| id == CSSValueWebkitFillAvailable || id == CSSValueWebkitFitContent || |
| id == CSSValueMinContent || id == CSSValueMaxContent || |
| id == CSSValueFitContent) { |
| if (context.useCounter()) { |
| switch (id) { |
| case CSSValueWebkitMinContent: |
| context.useCounter()->count(UseCounter::CSSValuePrefixedMinContent); |
| break; |
| case CSSValueWebkitMaxContent: |
| context.useCounter()->count(UseCounter::CSSValuePrefixedMaxContent); |
| break; |
| case CSSValueWebkitFillAvailable: |
| context.useCounter()->count( |
| UseCounter::CSSValuePrefixedFillAvailable); |
| break; |
| case CSSValueWebkitFitContent: |
| context.useCounter()->count(UseCounter::CSSValuePrefixedFitContent); |
| break; |
| default: |
| break; |
| } |
| } |
| return true; |
| } |
| return false; |
| } |
| |
| static CSSValue* consumeMaxWidthOrHeight( |
| CSSParserTokenRange& range, |
| const CSSParserContext& context, |
| UnitlessQuirk unitless = UnitlessQuirk::Forbid) { |
| if (range.peek().id() == CSSValueNone || |
| validWidthOrHeightKeyword(range.peek().id(), context)) |
| return consumeIdent(range); |
| return consumeLengthOrPercent(range, context.mode(), ValueRangeNonNegative, |
| unitless); |
| } |
| |
| static CSSValue* consumeWidthOrHeight( |
| CSSParserTokenRange& range, |
| const CSSParserContext& context, |
| UnitlessQuirk unitless = UnitlessQuirk::Forbid) { |
| if (range.peek().id() == CSSValueAuto || |
| validWidthOrHeightKeyword(range.peek().id(), context)) |
| return consumeIdent(range); |
| return consumeLengthOrPercent(range, context.mode(), ValueRangeNonNegative, |
| unitless); |
| } |
| |
| static CSSValue* consumeMarginOrOffset(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode, |
| UnitlessQuirk unitless) { |
| if (range.peek().id() == CSSValueAuto) |
| return consumeIdent(range); |
| return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, unitless); |
| } |
| |
| static CSSValue* consumeClipComponent(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| if (range.peek().id() == CSSValueAuto) |
| return consumeIdent(range); |
| return consumeLength(range, cssParserMode, ValueRangeAll, |
| UnitlessQuirk::Allow); |
| } |
| |
| static CSSValue* consumeClip(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| if (range.peek().id() == CSSValueAuto) |
| return consumeIdent(range); |
| |
| if (range.peek().functionId() != CSSValueRect) |
| return nullptr; |
| |
| CSSParserTokenRange args = consumeFunction(range); |
| // rect(t, r, b, l) || rect(t r b l) |
| CSSValue* top = consumeClipComponent(args, cssParserMode); |
| if (!top) |
| return nullptr; |
| bool needsComma = consumeCommaIncludingWhitespace(args); |
| CSSValue* right = consumeClipComponent(args, cssParserMode); |
| if (!right || (needsComma && !consumeCommaIncludingWhitespace(args))) |
| return nullptr; |
| CSSValue* bottom = consumeClipComponent(args, cssParserMode); |
| if (!bottom || (needsComma && !consumeCommaIncludingWhitespace(args))) |
| return nullptr; |
| CSSValue* left = consumeClipComponent(args, cssParserMode); |
| if (!left || !args.atEnd()) |
| return nullptr; |
| return CSSQuadValue::create(top, right, bottom, left, |
| CSSQuadValue::SerializeAsRect); |
| } |
| |
| static bool consumePan(CSSParserTokenRange& range, |
| CSSValue*& panX, |
| CSSValue*& panY, |
| CSSValue*& pinchZoom) { |
| CSSValueID id = range.peek().id(); |
| if ((id == CSSValuePanX || id == CSSValuePanRight || id == CSSValuePanLeft) && |
| !panX) { |
| if (id != CSSValuePanX && |
| !RuntimeEnabledFeatures::cssTouchActionPanDirectionsEnabled()) |
| return false; |
| panX = consumeIdent(range); |
| } else if ((id == CSSValuePanY || id == CSSValuePanDown || |
| id == CSSValuePanUp) && |
| !panY) { |
| if (id != CSSValuePanY && |
| !RuntimeEnabledFeatures::cssTouchActionPanDirectionsEnabled()) |
| return false; |
| panY = consumeIdent(range); |
| } else if (id == CSSValuePinchZoom && !pinchZoom && |
| RuntimeEnabledFeatures::cssTouchActionPinchZoomEnabled()) { |
| pinchZoom = consumeIdent(range); |
| } else { |
| return false; |
| } |
| return true; |
| } |
| |
| static CSSValue* consumeTouchAction(CSSParserTokenRange& range) { |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| CSSValueID id = range.peek().id(); |
| if (id == CSSValueAuto || id == CSSValueNone || id == CSSValueManipulation) { |
| list->append(*consumeIdent(range)); |
| return list; |
| } |
| |
| CSSValue* panX = nullptr; |
| CSSValue* panY = nullptr; |
| CSSValue* pinchZoom = nullptr; |
| if (!consumePan(range, panX, panY, pinchZoom)) |
| return nullptr; |
| if (!range.atEnd() && !consumePan(range, panX, panY, pinchZoom)) |
| return nullptr; |
| if (!range.atEnd() && !consumePan(range, panX, panY, pinchZoom)) |
| return nullptr; |
| |
| if (panX) |
| list->append(*panX); |
| if (panY) |
| list->append(*panY); |
| if (pinchZoom) |
| list->append(*pinchZoom); |
| return list; |
| } |
| |
| static CSSPrimitiveValue* consumeLineClamp(CSSParserTokenRange& range) { |
| if (range.peek().type() != PercentageToken && |
| range.peek().type() != NumberToken) |
| return nullptr; |
| CSSPrimitiveValue* clampValue = consumePercent(range, ValueRangeNonNegative); |
| if (clampValue) |
| return clampValue; |
| // When specifying number of lines, don't allow 0 as a valid value. |
| return consumePositiveInteger(range); |
| } |
| |
| static CSSValue* consumeLocale(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueAuto) |
| return consumeIdent(range); |
| return consumeString(range); |
| } |
| |
| static CSSValue* consumeColumnWidth(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueAuto) |
| return consumeIdent(range); |
| // Always parse lengths in strict mode here, since it would be ambiguous |
| // otherwise when used in the 'columns' shorthand property. |
| CSSPrimitiveValue* columnWidth = |
| consumeLength(range, HTMLStandardMode, ValueRangeNonNegative); |
| if (!columnWidth || |
| (!columnWidth->isCalculated() && columnWidth->getDoubleValue() == 0)) |
| return nullptr; |
| return columnWidth; |
| } |
| |
| static CSSValue* consumeColumnCount(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueAuto) |
| return consumeIdent(range); |
| return consumePositiveInteger(range); |
| } |
| |
| static CSSValue* consumeColumnGap(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| if (range.peek().id() == CSSValueNormal) |
| return consumeIdent(range); |
| return consumeLength(range, cssParserMode, ValueRangeNonNegative); |
| } |
| |
| static CSSValue* consumeColumnSpan(CSSParserTokenRange& range) { |
| return consumeIdent<CSSValueAll, CSSValueNone>(range); |
| } |
| |
| static CSSValue* consumeZoom(CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| const CSSParserToken& token = range.peek(); |
| CSSValue* zoom = nullptr; |
| if (token.type() == IdentToken) { |
| zoom = consumeIdent<CSSValueNormal, CSSValueReset, CSSValueDocument>(range); |
| } else { |
| zoom = consumePercent(range, ValueRangeNonNegative); |
| if (!zoom) |
| zoom = consumeNumber(range, ValueRangeNonNegative); |
| } |
| if (zoom && context.useCounter()) { |
| if (!(token.id() == CSSValueNormal || |
| (token.type() == NumberToken && |
| toCSSPrimitiveValue(zoom)->getDoubleValue() == 1) || |
| (token.type() == PercentageToken && |
| toCSSPrimitiveValue(zoom)->getDoubleValue() == 100))) |
| context.useCounter()->count(UseCounter::CSSZoomNotEqualToOne); |
| if (token.id() == CSSValueReset) |
| context.useCounter()->count(UseCounter::CSSZoomReset); |
| if (token.id() == CSSValueDocument) |
| context.useCounter()->count(UseCounter::CSSZoomDocument); |
| } |
| return zoom; |
| } |
| |
| static CSSValue* consumeAnimationIterationCount(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueInfinite) |
| return consumeIdent(range); |
| return consumeNumber(range, ValueRangeNonNegative); |
| } |
| |
| static CSSValue* consumeAnimationName(CSSParserTokenRange& range, |
| const CSSParserContext& context, |
| bool allowQuotedName) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| |
| if (allowQuotedName && range.peek().type() == StringToken) { |
| // Legacy support for strings in prefixed animations. |
| if (context.useCounter()) |
| context.useCounter()->count(UseCounter::QuotedAnimationName); |
| |
| const CSSParserToken& token = range.consumeIncludingWhitespace(); |
| if (equalIgnoringASCIICase(token.value(), "none")) |
| return CSSIdentifierValue::create(CSSValueNone); |
| return CSSCustomIdentValue::create(token.value().toAtomicString()); |
| } |
| |
| return consumeCustomIdent(range); |
| } |
| |
| static CSSValue* consumeTransitionProperty(CSSParserTokenRange& range) { |
| const CSSParserToken& token = range.peek(); |
| if (token.type() != IdentToken) |
| return nullptr; |
| if (token.id() == CSSValueNone) |
| return consumeIdent(range); |
| |
| CSSPropertyID unresolvedProperty = token.parseAsUnresolvedCSSPropertyID(); |
| if (unresolvedProperty != CSSPropertyInvalid && |
| unresolvedProperty != CSSPropertyVariable) { |
| DCHECK(CSSPropertyMetadata::isEnabledProperty(unresolvedProperty)); |
| range.consumeIncludingWhitespace(); |
| return CSSCustomIdentValue::create(unresolvedProperty); |
| } |
| return consumeCustomIdent(range); |
| } |
| |
| static CSSValue* consumeSteps(CSSParserTokenRange& range) { |
| ASSERT(range.peek().functionId() == CSSValueSteps); |
| CSSParserTokenRange rangeCopy = range; |
| CSSParserTokenRange args = consumeFunction(rangeCopy); |
| |
| CSSPrimitiveValue* steps = consumePositiveInteger(args); |
| if (!steps) |
| return nullptr; |
| |
| StepsTimingFunction::StepPosition position = |
| StepsTimingFunction::StepPosition::END; |
| if (consumeCommaIncludingWhitespace(args)) { |
| switch (args.consumeIncludingWhitespace().id()) { |
| case CSSValueMiddle: |
| if (!RuntimeEnabledFeatures::webAnimationsAPIEnabled()) |
| return nullptr; |
| position = StepsTimingFunction::StepPosition::MIDDLE; |
| break; |
| case CSSValueStart: |
| position = StepsTimingFunction::StepPosition::START; |
| break; |
| case CSSValueEnd: |
| position = StepsTimingFunction::StepPosition::END; |
| break; |
| default: |
| return nullptr; |
| } |
| } |
| |
| if (!args.atEnd()) |
| return nullptr; |
| |
| range = rangeCopy; |
| return CSSStepsTimingFunctionValue::create(steps->getIntValue(), position); |
| } |
| |
| static CSSValue* consumeCubicBezier(CSSParserTokenRange& range) { |
| ASSERT(range.peek().functionId() == CSSValueCubicBezier); |
| 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); |
| } |
| |
| return nullptr; |
| } |
| |
| static CSSValue* consumeAnimationTimingFunction(CSSParserTokenRange& range) { |
| CSSValueID id = range.peek().id(); |
| if (id == CSSValueEase || id == CSSValueLinear || id == CSSValueEaseIn || |
| id == CSSValueEaseOut || id == CSSValueEaseInOut || |
| id == CSSValueStepStart || id == CSSValueStepEnd || |
| id == CSSValueStepMiddle) |
| return consumeIdent(range); |
| |
| CSSValueID function = range.peek().functionId(); |
| if (function == CSSValueSteps) |
| return consumeSteps(range); |
| if (function == CSSValueCubicBezier) |
| return consumeCubicBezier(range); |
| return nullptr; |
| } |
| |
| static CSSValue* consumeAnimationValue(CSSPropertyID property, |
| CSSParserTokenRange& range, |
| const CSSParserContext& context, |
| bool useLegacyParsing) { |
| switch (property) { |
| case CSSPropertyAnimationDelay: |
| case CSSPropertyTransitionDelay: |
| return consumeTime(range, ValueRangeAll); |
| case CSSPropertyAnimationDirection: |
| return consumeIdent<CSSValueNormal, CSSValueAlternate, CSSValueReverse, |
| CSSValueAlternateReverse>(range); |
| case CSSPropertyAnimationDuration: |
| case CSSPropertyTransitionDuration: |
| return consumeTime(range, ValueRangeNonNegative); |
| case CSSPropertyAnimationFillMode: |
| return consumeIdent<CSSValueNone, CSSValueForwards, CSSValueBackwards, |
| CSSValueBoth>(range); |
| case CSSPropertyAnimationIterationCount: |
| return consumeAnimationIterationCount(range); |
| case CSSPropertyAnimationName: |
| return consumeAnimationName(range, context, useLegacyParsing); |
| case CSSPropertyAnimationPlayState: |
| return consumeIdent<CSSValueRunning, CSSValuePaused>(range); |
| case CSSPropertyTransitionProperty: |
| return consumeTransitionProperty(range); |
| case CSSPropertyAnimationTimingFunction: |
| case CSSPropertyTransitionTimingFunction: |
| return consumeAnimationTimingFunction(range); |
| default: |
| ASSERT_NOT_REACHED(); |
| return nullptr; |
| } |
| } |
| |
| static bool isValidAnimationPropertyList(CSSPropertyID property, |
| const CSSValueList& valueList) { |
| if (property != CSSPropertyTransitionProperty || valueList.length() < 2) |
| return true; |
| for (auto& value : valueList) { |
| if (value->isIdentifierValue() && |
| toCSSIdentifierValue(*value).getValueID() == CSSValueNone) |
| return false; |
| } |
| return true; |
| } |
| |
| static CSSValueList* consumeAnimationPropertyList( |
| CSSPropertyID property, |
| CSSParserTokenRange& range, |
| const CSSParserContext& context, |
| bool useLegacyParsing) { |
| CSSValueList* list = CSSValueList::createCommaSeparated(); |
| do { |
| CSSValue* value = |
| consumeAnimationValue(property, range, context, useLegacyParsing); |
| if (!value) |
| return nullptr; |
| list->append(*value); |
| } while (consumeCommaIncludingWhitespace(range)); |
| if (!isValidAnimationPropertyList(property, *list)) |
| return nullptr; |
| ASSERT(list->length()); |
| return list; |
| } |
| |
| bool CSSPropertyParser::consumeAnimationShorthand( |
| const StylePropertyShorthand& shorthand, |
| bool useLegacyParsing, |
| bool important) { |
| const unsigned longhandCount = shorthand.length(); |
| CSSValueList* longhands[8]; |
| ASSERT(longhandCount <= 8); |
| for (size_t i = 0; i < longhandCount; ++i) |
| longhands[i] = CSSValueList::createCommaSeparated(); |
| |
| do { |
| bool parsedLonghand[8] = {false}; |
| do { |
| bool foundProperty = false; |
| for (size_t i = 0; i < longhandCount; ++i) { |
| if (parsedLonghand[i]) |
| continue; |
| |
| if (CSSValue* value = |
| consumeAnimationValue(shorthand.properties()[i], m_range, |
| m_context, useLegacyParsing)) { |
| parsedLonghand[i] = true; |
| foundProperty = true; |
| longhands[i]->append(*value); |
| break; |
| } |
| } |
| if (!foundProperty) |
| return false; |
| } while (!m_range.atEnd() && m_range.peek().type() != CommaToken); |
| |
| // TODO(timloh): This will make invalid longhands, see crbug.com/386459 |
| for (size_t i = 0; i < longhandCount; ++i) { |
| if (!parsedLonghand[i]) |
| longhands[i]->append(*CSSInitialValue::createLegacyImplicit()); |
| parsedLonghand[i] = false; |
| } |
| } while (consumeCommaIncludingWhitespace(m_range)); |
| |
| for (size_t i = 0; i < longhandCount; ++i) { |
| if (!isValidAnimationPropertyList(shorthand.properties()[i], *longhands[i])) |
| return false; |
| } |
| |
| for (size_t i = 0; i < longhandCount; ++i) |
| addProperty(shorthand.properties()[i], shorthand.id(), *longhands[i], |
| important); |
| |
| return m_range.atEnd(); |
| } |
| |
| static CSSValue* consumeZIndex(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueAuto) |
| return consumeIdent(range); |
| return consumeInteger(range); |
| } |
| |
| static CSSShadowValue* parseSingleShadow(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode, |
| bool allowInset, |
| bool allowSpread) { |
| CSSIdentifierValue* style = nullptr; |
| CSSValue* color = nullptr; |
| |
| if (range.atEnd()) |
| return nullptr; |
| if (range.peek().id() == CSSValueInset) { |
| if (!allowInset) |
| return nullptr; |
| style = consumeIdent(range); |
| } |
| color = consumeColor(range, cssParserMode); |
| |
| CSSPrimitiveValue* horizontalOffset = |
| consumeLength(range, cssParserMode, ValueRangeAll); |
| if (!horizontalOffset) |
| return nullptr; |
| |
| CSSPrimitiveValue* verticalOffset = |
| consumeLength(range, cssParserMode, ValueRangeAll); |
| if (!verticalOffset) |
| return nullptr; |
| |
| CSSPrimitiveValue* blurRadius = |
| consumeLength(range, cssParserMode, ValueRangeAll); |
| CSSPrimitiveValue* spreadDistance = nullptr; |
| if (blurRadius) { |
| // Blur radius must be non-negative. |
| if (blurRadius->getDoubleValue() < 0) |
| return nullptr; |
| if (allowSpread) |
| spreadDistance = consumeLength(range, cssParserMode, ValueRangeAll); |
| } |
| |
| if (!range.atEnd()) { |
| if (!color) |
| color = consumeColor(range, cssParserMode); |
| if (range.peek().id() == CSSValueInset) { |
| if (!allowInset || style) |
| return nullptr; |
| style = consumeIdent(range); |
| } |
| } |
| return CSSShadowValue::create(horizontalOffset, verticalOffset, blurRadius, |
| spreadDistance, style, color); |
| } |
| |
| static CSSValue* consumeShadow(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode, |
| bool isBoxShadowProperty) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| |
| CSSValueList* shadowValueList = CSSValueList::createCommaSeparated(); |
| do { |
| if (CSSShadowValue* shadowValue = parseSingleShadow( |
| range, cssParserMode, isBoxShadowProperty, isBoxShadowProperty)) |
| shadowValueList->append(*shadowValue); |
| else |
| return nullptr; |
| } while (consumeCommaIncludingWhitespace(range)); |
| return shadowValueList; |
| } |
| |
| static CSSFunctionValue* consumeFilterFunction( |
| CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| CSSValueID filterType = range.peek().functionId(); |
| if (filterType < CSSValueInvert || filterType > CSSValueDropShadow) |
| return nullptr; |
| CSSParserTokenRange args = consumeFunction(range); |
| CSSFunctionValue* filterValue = CSSFunctionValue::create(filterType); |
| CSSValue* parsedValue = nullptr; |
| |
| if (filterType == CSSValueDropShadow) { |
| parsedValue = parseSingleShadow(args, context.mode(), false, false); |
| } else { |
| if (args.atEnd()) { |
| if (context.useCounter()) |
| context.useCounter()->count(UseCounter::CSSFilterFunctionNoArguments); |
| return filterValue; |
| } |
| if (filterType == CSSValueBrightness) { |
| // FIXME (crbug.com/397061): Support calc expressions like calc(10% + 0.5) |
| parsedValue = consumePercent(args, ValueRangeAll); |
| if (!parsedValue) |
| parsedValue = consumeNumber(args, ValueRangeAll); |
| } else if (filterType == CSSValueHueRotate) { |
| parsedValue = consumeAngle(args); |
| } else if (filterType == CSSValueBlur) { |
| parsedValue = |
| consumeLength(args, HTMLStandardMode, ValueRangeNonNegative); |
| } else { |
| // FIXME (crbug.com/397061): Support calc expressions like calc(10% + 0.5) |
| parsedValue = consumePercent(args, ValueRangeNonNegative); |
| if (!parsedValue) |
| parsedValue = consumeNumber(args, ValueRangeNonNegative); |
| if (parsedValue && filterType != CSSValueSaturate && |
| filterType != CSSValueContrast) { |
| bool isPercentage = toCSSPrimitiveValue(parsedValue)->isPercentage(); |
| double maxAllowed = isPercentage ? 100.0 : 1.0; |
| if (toCSSPrimitiveValue(parsedValue)->getDoubleValue() > maxAllowed) { |
| parsedValue = CSSPrimitiveValue::create( |
| maxAllowed, isPercentage ? CSSPrimitiveValue::UnitType::Percentage |
| : CSSPrimitiveValue::UnitType::Number); |
| } |
| } |
| } |
| } |
| if (!parsedValue || !args.atEnd()) |
| return nullptr; |
| filterValue->append(*parsedValue); |
| return filterValue; |
| } |
| |
| static CSSValue* consumeFilter(CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| do { |
| CSSValue* filterValue = consumeUrl(range); |
| if (!filterValue) { |
| filterValue = consumeFilterFunction(range, context); |
| if (!filterValue) |
| return nullptr; |
| } |
| list->append(*filterValue); |
| } while (!range.atEnd()); |
| return list; |
| } |
| |
| static CSSValue* consumeTextDecorationLine(CSSParserTokenRange& range) { |
| CSSValueID id = range.peek().id(); |
| if (id == CSSValueNone) |
| return consumeIdent(range); |
| |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| while (true) { |
| CSSIdentifierValue* ident = |
| consumeIdent<CSSValueBlink, CSSValueUnderline, CSSValueOverline, |
| CSSValueLineThrough>(range); |
| if (!ident) |
| break; |
| if (list->hasValue(*ident)) |
| return nullptr; |
| list->append(*ident); |
| } |
| |
| if (!list->length()) |
| return nullptr; |
| return list; |
| } |
| |
| // none | strict | content | [ layout || style || paint || size ] |
| static CSSValue* consumeContain(CSSParserTokenRange& range) { |
| CSSValueID id = range.peek().id(); |
| if (id == CSSValueNone) |
| return consumeIdent(range); |
| |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| if (id == CSSValueStrict || id == CSSValueContent) { |
| list->append(*consumeIdent(range)); |
| return list; |
| } |
| while (true) { |
| CSSIdentifierValue* ident = |
| consumeIdent<CSSValuePaint, CSSValueLayout, CSSValueStyle, |
| CSSValueSize>(range); |
| if (!ident) |
| break; |
| if (list->hasValue(*ident)) |
| return nullptr; |
| list->append(*ident); |
| } |
| |
| if (!list->length()) |
| return nullptr; |
| return list; |
| } |
| |
| static CSSValue* consumePath(CSSParserTokenRange& range) { |
| // FIXME: Add support for <url>, <basic-shape>, <geometry-box>. |
| if (range.peek().functionId() != CSSValuePath) |
| return nullptr; |
| |
| CSSParserTokenRange functionRange = range; |
| CSSParserTokenRange functionArgs = consumeFunction(functionRange); |
| |
| if (functionArgs.peek().type() != StringToken) |
| return nullptr; |
| String pathString = |
| functionArgs.consumeIncludingWhitespace().value().toString(); |
| |
| std::unique_ptr<SVGPathByteStream> byteStream = SVGPathByteStream::create(); |
| if (buildByteStreamFromString(pathString, *byteStream) != |
| SVGParseStatus::NoError || |
| !functionArgs.atEnd()) |
| return nullptr; |
| |
| range = functionRange; |
| if (byteStream->isEmpty()) |
| return CSSIdentifierValue::create(CSSValueNone); |
| return CSSPathValue::create(std::move(byteStream)); |
| } |
| |
| static CSSValue* consumePathOrNone(CSSParserTokenRange& range) { |
| CSSValueID id = range.peek().id(); |
| if (id == CSSValueNone) |
| return consumeIdent(range); |
| |
| return consumePath(range); |
| } |
| |
| static CSSValue* consumeOffsetRotation(CSSParserTokenRange& range) { |
| CSSValue* angle = consumeAngle(range); |
| CSSValue* keyword = consumeIdent<CSSValueAuto, CSSValueReverse>(range); |
| if (!angle && !keyword) |
| return nullptr; |
| |
| if (!angle) |
| angle = consumeAngle(range); |
| |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| if (keyword) |
| list->append(*keyword); |
| if (angle) |
| list->append(*angle); |
| return list; |
| } |
| |
| static CSSValue* consumeOffsetAnchor(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| CSSValueID id = range.peek().id(); |
| if (id == CSSValueAuto) |
| return consumeIdent(range); |
| return consumePosition(range, cssParserMode, UnitlessQuirk::Forbid); |
| } |
| |
| static CSSValue* consumeOffsetPosition(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode, |
| UseCounter* useCounter) { |
| CSSValueID id = range.peek().id(); |
| if (id == CSSValueAuto) |
| return consumeIdent(range); |
| CSSValue* value = |
| consumePosition(range, cssParserMode, UnitlessQuirk::Forbid); |
| |
| // Count when we receive a valid position other than 'auto'. |
| if (useCounter && value && value->isValuePair()) |
| useCounter->count(UseCounter::CSSOffsetInEffect); |
| return value; |
| } |
| |
| static CSSValue* consumeOffsetPath(CSSParserTokenRange& range, |
| UseCounter* useCounter, |
| bool isMotionPath) { |
| CSSValue* value = consumePathOrNone(range); |
| |
| // Count when we receive a valid path other than 'none'. |
| if (useCounter && value && !value->isIdentifierValue()) { |
| if (isMotionPath) |
| useCounter->count(UseCounter::CSSMotionInEffect); |
| else |
| useCounter->count(UseCounter::CSSOffsetInEffect); |
| } |
| return value; |
| } |
| |
| // offset: <offset-path> <offset-distance> <offset-rotation> |
| bool CSSPropertyParser::consumeOffsetShorthand(bool important) { |
| const CSSValue* offsetPath = |
| consumeOffsetPath(m_range, m_context.useCounter(), false); |
| const CSSValue* offsetDistance = |
| consumeLengthOrPercent(m_range, m_context.mode(), ValueRangeAll); |
| const CSSValue* offsetRotation = consumeOffsetRotation(m_range); |
| if (!offsetPath || !offsetDistance || !offsetRotation || !m_range.atEnd()) |
| return false; |
| |
| addProperty(CSSPropertyOffsetPath, CSSPropertyOffset, *offsetPath, important); |
| addProperty(CSSPropertyOffsetDistance, CSSPropertyOffset, *offsetDistance, |
| important); |
| addProperty(CSSPropertyOffsetRotation, CSSPropertyOffset, *offsetRotation, |
| important); |
| |
| return true; |
| } |
| |
| static CSSValue* consumeTextEmphasisStyle(CSSParserTokenRange& range) { |
| CSSValueID id = range.peek().id(); |
| if (id == CSSValueNone) |
| return consumeIdent(range); |
| |
| if (CSSValue* textEmphasisStyle = consumeString(range)) |
| return textEmphasisStyle; |
| |
| CSSIdentifierValue* fill = consumeIdent<CSSValueFilled, CSSValueOpen>(range); |
| CSSIdentifierValue* shape = |
| consumeIdent<CSSValueDot, CSSValueCircle, CSSValueDoubleCircle, |
| CSSValueTriangle, CSSValueSesame>(range); |
| if (!fill) |
| fill = consumeIdent<CSSValueFilled, CSSValueOpen>(range); |
| if (fill && shape) { |
| CSSValueList* parsedValues = CSSValueList::createSpaceSeparated(); |
| parsedValues->append(*fill); |
| parsedValues->append(*shape); |
| return parsedValues; |
| } |
| if (fill) |
| return fill; |
| if (shape) |
| return shape; |
| return nullptr; |
| } |
| |
| static CSSValue* consumeOutlineColor(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| // Allow the special focus color even in HTML Standard parsing mode. |
| if (range.peek().id() == CSSValueWebkitFocusRingColor) |
| return consumeIdent(range); |
| return consumeColor(range, cssParserMode); |
| } |
| |
| static CSSValue* consumeLineWidth(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode, |
| UnitlessQuirk unitless) { |
| CSSValueID id = range.peek().id(); |
| if (id == CSSValueThin || id == CSSValueMedium || id == CSSValueThick) |
| return consumeIdent(range); |
| return consumeLength(range, cssParserMode, ValueRangeNonNegative, unitless); |
| } |
| |
| static CSSValue* consumeBorderWidth(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode, |
| UnitlessQuirk unitless) { |
| return consumeLineWidth(range, cssParserMode, unitless); |
| } |
| |
| static CSSValue* consumeTextStrokeWidth(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| return consumeLineWidth(range, cssParserMode, UnitlessQuirk::Forbid); |
| } |
| |
| static CSSValue* consumeColumnRuleWidth(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| return consumeLineWidth(range, cssParserMode, UnitlessQuirk::Forbid); |
| } |
| |
| static bool consumeTranslate3d(CSSParserTokenRange& args, |
| CSSParserMode cssParserMode, |
| CSSFunctionValue*& transformValue) { |
| unsigned numberOfArguments = 2; |
| CSSValue* parsedValue = nullptr; |
| do { |
| parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll); |
| if (!parsedValue) |
| return false; |
| transformValue->append(*parsedValue); |
| if (!consumeCommaIncludingWhitespace(args)) |
| return false; |
| } while (--numberOfArguments); |
| parsedValue = consumeLength(args, cssParserMode, ValueRangeAll); |
| if (!parsedValue) |
| return false; |
| transformValue->append(*parsedValue); |
| return true; |
| } |
| |
| static bool consumeNumbers(CSSParserTokenRange& args, |
| CSSFunctionValue*& transformValue, |
| unsigned numberOfArguments) { |
| do { |
| CSSValue* parsedValue = consumeNumber(args, ValueRangeAll); |
| if (!parsedValue) |
| return false; |
| transformValue->append(*parsedValue); |
| if (--numberOfArguments && !consumeCommaIncludingWhitespace(args)) |
| return false; |
| } while (numberOfArguments); |
| return true; |
| } |
| |
| static bool consumePerspective(CSSParserTokenRange& args, |
| CSSParserMode cssParserMode, |
| CSSFunctionValue*& transformValue, |
| bool useLegacyParsing) { |
| CSSPrimitiveValue* parsedValue = |
| consumeLength(args, cssParserMode, ValueRangeNonNegative); |
| if (!parsedValue && useLegacyParsing) { |
| double perspective; |
| if (!consumeNumberRaw(args, perspective) || perspective < 0) |
| return false; |
| parsedValue = CSSPrimitiveValue::create( |
| perspective, CSSPrimitiveValue::UnitType::Pixels); |
| } |
| if (!parsedValue) |
| return false; |
| transformValue->append(*parsedValue); |
| return true; |
| } |
| |
| static CSSValue* consumeTransformValue(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode, |
| bool useLegacyParsing) { |
| CSSValueID functionId = range.peek().functionId(); |
| if (functionId == CSSValueInvalid) |
| return nullptr; |
| CSSParserTokenRange args = consumeFunction(range); |
| if (args.atEnd()) |
| return nullptr; |
| CSSFunctionValue* transformValue = CSSFunctionValue::create(functionId); |
| CSSValue* parsedValue = nullptr; |
| switch (functionId) { |
| case CSSValueRotate: |
| case CSSValueRotateX: |
| case CSSValueRotateY: |
| case CSSValueRotateZ: |
| case CSSValueSkewX: |
| case CSSValueSkewY: |
| case CSSValueSkew: |
| parsedValue = consumeAngle(args); |
| if (!parsedValue) |
| return nullptr; |
| if (functionId == CSSValueSkew && consumeCommaIncludingWhitespace(args)) { |
| transformValue->append(*parsedValue); |
| parsedValue = consumeAngle(args); |
| if (!parsedValue) |
| return nullptr; |
| } |
| break; |
| case CSSValueScaleX: |
| case CSSValueScaleY: |
| case CSSValueScaleZ: |
| case CSSValueScale: |
| parsedValue = consumeNumber(args, ValueRangeAll); |
| if (!parsedValue) |
| return nullptr; |
| if (functionId == CSSValueScale && |
| consumeCommaIncludingWhitespace(args)) { |
| transformValue->append(*parsedValue); |
| parsedValue = consumeNumber(args, ValueRangeAll); |
| if (!parsedValue) |
| return nullptr; |
| } |
| break; |
| case CSSValuePerspective: |
| if (!consumePerspective(args, cssParserMode, transformValue, |
| useLegacyParsing)) |
| return nullptr; |
| break; |
| case CSSValueTranslateX: |
| case CSSValueTranslateY: |
| case CSSValueTranslate: |
| parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll); |
| if (!parsedValue) |
| return nullptr; |
| if (functionId == CSSValueTranslate && |
| consumeCommaIncludingWhitespace(args)) { |
| transformValue->append(*parsedValue); |
| parsedValue = |
| consumeLengthOrPercent(args, cssParserMode, ValueRangeAll); |
| if (!parsedValue) |
| return nullptr; |
| } |
| break; |
| case CSSValueTranslateZ: |
| parsedValue = consumeLength(args, cssParserMode, ValueRangeAll); |
| break; |
| case CSSValueMatrix: |
| case CSSValueMatrix3d: |
| if (!consumeNumbers(args, transformValue, |
| (functionId == CSSValueMatrix3d) ? 16 : 6)) |
| return nullptr; |
| break; |
| case CSSValueScale3d: |
| if (!consumeNumbers(args, transformValue, 3)) |
| return nullptr; |
| break; |
| case CSSValueRotate3d: |
| if (!consumeNumbers(args, transformValue, 3) || |
| !consumeCommaIncludingWhitespace(args)) |
| return nullptr; |
| parsedValue = consumeAngle(args); |
| if (!parsedValue) |
| return nullptr; |
| break; |
| case CSSValueTranslate3d: |
| if (!consumeTranslate3d(args, cssParserMode, transformValue)) |
| return nullptr; |
| break; |
| default: |
| return nullptr; |
| } |
| if (parsedValue) |
| transformValue->append(*parsedValue); |
| if (!args.atEnd()) |
| return nullptr; |
| return transformValue; |
| } |
| |
| static CSSValue* consumeTransform(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode, |
| bool useLegacyParsing) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| do { |
| CSSValue* parsedTransformValue = |
| consumeTransformValue(range, cssParserMode, useLegacyParsing); |
| if (!parsedTransformValue) |
| return nullptr; |
| list->append(*parsedTransformValue); |
| } while (!range.atEnd()); |
| |
| return list; |
| } |
| |
| template <CSSValueID start, CSSValueID end> |
| static CSSValue* consumePositionLonghand(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| if (range.peek().type() == IdentToken) { |
| CSSValueID id = range.peek().id(); |
| int percent; |
| if (id == start) |
| percent = 0; |
| else if (id == CSSValueCenter) |
| percent = 50; |
| else if (id == end) |
| percent = 100; |
| else |
| return nullptr; |
| range.consumeIncludingWhitespace(); |
| return CSSPrimitiveValue::create(percent, |
| CSSPrimitiveValue::UnitType::Percentage); |
| } |
| return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll); |
| } |
| |
| static CSSValue* consumePositionX(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| return consumePositionLonghand<CSSValueLeft, CSSValueRight>(range, |
| cssParserMode); |
| } |
| |
| static CSSValue* consumePositionY(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| return consumePositionLonghand<CSSValueTop, CSSValueBottom>(range, |
| cssParserMode); |
| } |
| |
| static CSSValue* consumePaintStroke(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| CSSURIValue* url = consumeUrl(range); |
| if (url) { |
| CSSValue* parsedValue = nullptr; |
| if (range.peek().id() == CSSValueNone) |
| parsedValue = consumeIdent(range); |
| else |
| parsedValue = consumeColor(range, cssParserMode); |
| if (parsedValue) { |
| CSSValueList* values = CSSValueList::createSpaceSeparated(); |
| values->append(*url); |
| values->append(*parsedValue); |
| return values; |
| } |
| return url; |
| } |
| return consumeColor(range, cssParserMode); |
| } |
| |
| static CSSValue* consumePaintOrder(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueNormal) |
| return consumeIdent(range); |
| |
| Vector<CSSValueID, 3> paintTypeList; |
| CSSIdentifierValue* fill = nullptr; |
| CSSIdentifierValue* stroke = nullptr; |
| CSSIdentifierValue* markers = nullptr; |
| do { |
| CSSValueID id = range.peek().id(); |
| if (id == CSSValueFill && !fill) |
| fill = consumeIdent(range); |
| else if (id == CSSValueStroke && !stroke) |
| stroke = consumeIdent(range); |
| else if (id == CSSValueMarkers && !markers) |
| markers = consumeIdent(range); |
| else |
| return nullptr; |
| paintTypeList.append(id); |
| } while (!range.atEnd()); |
| |
| // After parsing we serialize the paint-order list. Since it is not possible |
| // to pop a last list items from CSSValueList without bigger cost, we create |
| // the list after parsing. |
| CSSValueID firstPaintOrderType = paintTypeList.at(0); |
| CSSValueList* paintOrderList = CSSValueList::createSpaceSeparated(); |
| switch (firstPaintOrderType) { |
| case CSSValueFill: |
| case CSSValueStroke: |
| paintOrderList->append(firstPaintOrderType == CSSValueFill ? *fill |
| : *stroke); |
| if (paintTypeList.size() > 1) { |
| if (paintTypeList.at(1) == CSSValueMarkers) |
| paintOrderList->append(*markers); |
| } |
| break; |
| case CSSValueMarkers: |
| paintOrderList->append(*markers); |
| if (paintTypeList.size() > 1) { |
| if (paintTypeList.at(1) == CSSValueStroke) |
| paintOrderList->append(*stroke); |
| } |
| break; |
| default: |
| ASSERT_NOT_REACHED(); |
| } |
| |
| return paintOrderList; |
| } |
| |
| static CSSValue* consumeNoneOrURI(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| return consumeUrl(range); |
| } |
| |
| static CSSValue* consumeFlexBasis(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| // FIXME: Support intrinsic dimensions too. |
| if (range.peek().id() == CSSValueAuto) |
| return consumeIdent(range); |
| return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative); |
| } |
| |
| static CSSValue* consumeStrokeDasharray(CSSParserTokenRange& range) { |
| CSSValueID id = range.peek().id(); |
| if (id == CSSValueNone) |
| return consumeIdent(range); |
| |
| CSSValueList* dashes = CSSValueList::createCommaSeparated(); |
| do { |
| CSSPrimitiveValue* dash = |
| consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeNonNegative); |
| if (!dash || (consumeCommaIncludingWhitespace(range) && range.atEnd())) |
| return nullptr; |
| dashes->append(*dash); |
| } while (!range.atEnd()); |
| return dashes; |
| } |
| |
| static CSSValue* consumeBaselineShift(CSSParserTokenRange& range) { |
| CSSValueID id = range.peek().id(); |
| if (id == CSSValueBaseline || id == CSSValueSub || id == CSSValueSuper) |
| return consumeIdent(range); |
| return consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeAll); |
| } |
| |
| static CSSValue* consumeRxOrRy(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueAuto) |
| return consumeIdent(range); |
| return consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeAll, |
| UnitlessQuirk::Forbid); |
| } |
| |
| static CSSValue* consumeCursor(CSSParserTokenRange& range, |
| const CSSParserContext& context, |
| bool inQuirksMode) { |
| CSSValueList* list = nullptr; |
| while (CSSValue* image = |
| consumeImage(range, context, ConsumeGeneratedImage::Forbid)) { |
| double num; |
| IntPoint hotSpot(-1, -1); |
| bool hotSpotSpecified = false; |
| if (consumeNumberRaw(range, num)) { |
| hotSpot.setX(int(num)); |
| if (!consumeNumberRaw(range, num)) |
| return nullptr; |
| hotSpot.setY(int(num)); |
| hotSpotSpecified = true; |
| } |
| |
| if (!list) |
| list = CSSValueList::createCommaSeparated(); |
| |
| list->append( |
| *CSSCursorImageValue::create(image, hotSpotSpecified, hotSpot)); |
| if (!consumeCommaIncludingWhitespace(range)) |
| return nullptr; |
| } |
| |
| CSSValueID id = range.peek().id(); |
| if (!range.atEnd() && context.useCounter()) { |
| if (id == CSSValueWebkitZoomIn) |
| context.useCounter()->count(UseCounter::PrefixedCursorZoomIn); |
| else if (id == CSSValueWebkitZoomOut) |
| context.useCounter()->count(UseCounter::PrefixedCursorZoomOut); |
| } |
| CSSValue* cursorType = nullptr; |
| if (id == CSSValueHand) { |
| if (!inQuirksMode) // Non-standard behavior |
| return nullptr; |
| cursorType = CSSIdentifierValue::create(CSSValuePointer); |
| range.consumeIncludingWhitespace(); |
| } else if ((id >= CSSValueAuto && id <= CSSValueWebkitZoomOut) || |
| id == CSSValueCopy || id == CSSValueNone) { |
| cursorType = consumeIdent(range); |
| } else { |
| return nullptr; |
| } |
| |
| if (!list) |
| return cursorType; |
| list->append(*cursorType); |
| return list; |
| } |
| |
| static CSSValue* consumeAttr(CSSParserTokenRange args, |
| const CSSParserContext& context) { |
| if (args.peek().type() != IdentToken) |
| return nullptr; |
| |
| AtomicString attrName = |
| args.consumeIncludingWhitespace().value().toAtomicString(); |
| if (!args.atEnd()) |
| return nullptr; |
| |
| // TODO(esprehn): This should be lowerASCII(). |
| if (context.isHTMLDocument()) |
| attrName = attrName.lower(); |
| |
| CSSFunctionValue* attrValue = CSSFunctionValue::create(CSSValueAttr); |
| attrValue->append(*CSSCustomIdentValue::create(attrName)); |
| return attrValue; |
| } |
| |
| static CSSValue* consumeCounterContent(CSSParserTokenRange args, |
| bool counters) { |
| CSSCustomIdentValue* identifier = consumeCustomIdent(args); |
| if (!identifier) |
| return nullptr; |
| |
| CSSStringValue* separator = nullptr; |
| if (!counters) { |
| separator = CSSStringValue::create(String()); |
| } else { |
| if (!consumeCommaIncludingWhitespace(args) || |
| args.peek().type() != StringToken) |
| return nullptr; |
| separator = CSSStringValue::create( |
| args.consumeIncludingWhitespace().value().toString()); |
| } |
| |
| CSSIdentifierValue* listStyle = nullptr; |
| if (consumeCommaIncludingWhitespace(args)) { |
| CSSValueID id = args.peek().id(); |
| if ((id != CSSValueNone && |
| (id < CSSValueDisc || id > CSSValueKatakanaIroha))) |
| return nullptr; |
| listStyle = consumeIdent(args); |
| } else { |
| listStyle = CSSIdentifierValue::create(CSSValueDecimal); |
| } |
| |
| if (!args.atEnd()) |
| return nullptr; |
| return CSSCounterValue::create(identifier, listStyle, separator); |
| } |
| |
| static CSSValue* consumeContent(CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| if (identMatches<CSSValueNone, CSSValueNormal>(range.peek().id())) |
| return consumeIdent(range); |
| |
| CSSValueList* values = CSSValueList::createSpaceSeparated(); |
| |
| do { |
| CSSValue* parsedValue = consumeImage(range, context); |
| if (!parsedValue) |
| parsedValue = |
| consumeIdent<CSSValueOpenQuote, CSSValueCloseQuote, |
| CSSValueNoOpenQuote, CSSValueNoCloseQuote>(range); |
| if (!parsedValue) |
| parsedValue = consumeString(range); |
| if (!parsedValue) { |
| if (range.peek().functionId() == CSSValueAttr) |
| parsedValue = consumeAttr(consumeFunction(range), context); |
| else if (range.peek().functionId() == CSSValueCounter) |
| parsedValue = consumeCounterContent(consumeFunction(range), false); |
| else if (range.peek().functionId() == CSSValueCounters) |
| parsedValue = consumeCounterContent(consumeFunction(range), true); |
| if (!parsedValue) |
| return nullptr; |
| } |
| values->append(*parsedValue); |
| } while (!range.atEnd()); |
| |
| return values; |
| } |
| |
| static CSSValue* consumePerspective(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode, |
| CSSPropertyID unresolvedProperty) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| CSSPrimitiveValue* parsedValue = |
| consumeLength(range, cssParserMode, ValueRangeAll); |
| if (!parsedValue && |
| (unresolvedProperty == CSSPropertyAliasWebkitPerspective)) { |
| double perspective; |
| if (!consumeNumberRaw(range, perspective)) |
| return nullptr; |
| parsedValue = CSSPrimitiveValue::create( |
| perspective, CSSPrimitiveValue::UnitType::Pixels); |
| } |
| if (parsedValue && |
| (parsedValue->isCalculated() || parsedValue->getDoubleValue() > 0)) |
| return parsedValue; |
| return nullptr; |
| } |
| |
| static CSSValueList* consumePositionList(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| CSSValueList* positions = CSSValueList::createCommaSeparated(); |
| do { |
| CSSValue* position = |
| consumePosition(range, cssParserMode, UnitlessQuirk::Forbid); |
| if (!position) |
| return nullptr; |
| positions->append(*position); |
| } while (consumeCommaIncludingWhitespace(range)); |
| return positions; |
| } |
| |
| static CSSValue* consumeScrollSnapCoordinate(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| return consumePositionList(range, cssParserMode); |
| } |
| |
| static CSSValue* consumeScrollSnapPoints(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| if (range.peek().functionId() == CSSValueRepeat) { |
| CSSParserTokenRange args = consumeFunction(range); |
| CSSPrimitiveValue* parsedValue = |
| consumeLengthOrPercent(args, cssParserMode, ValueRangeNonNegative); |
| if (args.atEnd() && parsedValue && |
| (parsedValue->isCalculated() || parsedValue->getDoubleValue() > 0)) { |
| CSSFunctionValue* result = CSSFunctionValue::create(CSSValueRepeat); |
| result->append(*parsedValue); |
| return result; |
| } |
| } |
| return nullptr; |
| } |
| |
| static CSSValue* consumeBorderRadiusCorner(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| CSSValue* parsedValue1 = |
| consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative); |
| if (!parsedValue1) |
| return nullptr; |
| CSSValue* parsedValue2 = |
| consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative); |
| if (!parsedValue2) |
| parsedValue2 = parsedValue1; |
| return CSSValuePair::create(parsedValue1, parsedValue2, |
| CSSValuePair::DropIdenticalValues); |
| } |
| |
| static CSSValue* consumeVerticalAlign(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| CSSValue* parsedValue = |
| consumeIdentRange(range, CSSValueBaseline, CSSValueWebkitBaselineMiddle); |
| if (!parsedValue) |
| parsedValue = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, |
| UnitlessQuirk::Allow); |
| return parsedValue; |
| } |
| |
| static CSSValue* consumeShapeRadius(CSSParserTokenRange& args, |
| CSSParserMode cssParserMode) { |
| if (identMatches<CSSValueClosestSide, CSSValueFarthestSide>(args.peek().id())) |
| return consumeIdent(args); |
| return consumeLengthOrPercent(args, cssParserMode, ValueRangeNonNegative); |
| } |
| |
| static CSSBasicShapeCircleValue* consumeBasicShapeCircle( |
| CSSParserTokenRange& args, |
| const CSSParserContext& context) { |
| // spec: https://drafts.csswg.org/css-shapes/#supported-basic-shapes |
| // circle( [<shape-radius>]? [at <position>]? ) |
| CSSBasicShapeCircleValue* shape = CSSBasicShapeCircleValue::create(); |
| if (CSSValue* radius = consumeShapeRadius(args, context.mode())) |
| shape->setRadius(radius); |
| if (consumeIdent<CSSValueAt>(args)) { |
| CSSValue* centerX = nullptr; |
| CSSValue* centerY = nullptr; |
| if (!consumePosition(args, context.mode(), UnitlessQuirk::Forbid, centerX, |
| centerY)) |
| return nullptr; |
| shape->setCenterX(centerX); |
| shape->setCenterY(centerY); |
| } |
| return shape; |
| } |
| |
| static CSSBasicShapeEllipseValue* consumeBasicShapeEllipse( |
| CSSParserTokenRange& args, |
| const CSSParserContext& context) { |
| // spec: https://drafts.csswg.org/css-shapes/#supported-basic-shapes |
| // ellipse( [<shape-radius>{2}]? [at <position>]? ) |
| CSSBasicShapeEllipseValue* shape = CSSBasicShapeEllipseValue::create(); |
| if (CSSValue* radiusX = consumeShapeRadius(args, context.mode())) { |
| shape->setRadiusX(radiusX); |
| if (CSSValue* radiusY = consumeShapeRadius(args, context.mode())) |
| shape->setRadiusY(radiusY); |
| } |
| if (consumeIdent<CSSValueAt>(args)) { |
| CSSValue* centerX = nullptr; |
| CSSValue* centerY = nullptr; |
| if (!consumePosition(args, context.mode(), UnitlessQuirk::Forbid, centerX, |
| centerY)) |
| return nullptr; |
| shape->setCenterX(centerX); |
| shape->setCenterY(centerY); |
| } |
| return shape; |
| } |
| |
| static CSSBasicShapePolygonValue* consumeBasicShapePolygon( |
| CSSParserTokenRange& args, |
| const CSSParserContext& context) { |
| CSSBasicShapePolygonValue* shape = CSSBasicShapePolygonValue::create(); |
| if (identMatches<CSSValueEvenodd, CSSValueNonzero>(args.peek().id())) { |
| shape->setWindRule(args.consumeIncludingWhitespace().id() == CSSValueEvenodd |
| ? RULE_EVENODD |
| : RULE_NONZERO); |
| if (!consumeCommaIncludingWhitespace(args)) |
| return nullptr; |
| } |
| |
| do { |
| CSSPrimitiveValue* xLength = |
| consumeLengthOrPercent(args, context.mode(), ValueRangeAll); |
| if (!xLength) |
| return nullptr; |
| CSSPrimitiveValue* yLength = |
| consumeLengthOrPercent(args, context.mode(), ValueRangeAll); |
| if (!yLength) |
| return nullptr; |
| shape->appendPoint(xLength, yLength); |
| } while (consumeCommaIncludingWhitespace(args)); |
| return shape; |
| } |
| |
| static void complete4Sides(CSSValue* side[4]) { |
| if (side[3]) |
| return; |
| if (!side[2]) { |
| if (!side[1]) |
| side[1] = side[0]; |
| side[2] = side[0]; |
| } |
| side[3] = side[1]; |
| } |
| |
| static bool consumeRadii(CSSValue* horizontalRadii[4], |
| CSSValue* verticalRadii[4], |
| CSSParserTokenRange& range, |
| CSSParserMode cssParserMode, |
| bool useLegacyParsing) { |
| unsigned i = 0; |
| for (; i < 4 && !range.atEnd() && range.peek().type() != DelimiterToken; |
| ++i) { |
| horizontalRadii[i] = |
| consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative); |
| if (!horizontalRadii[i]) |
| return false; |
| } |
| if (!horizontalRadii[0]) |
| return false; |
| if (range.atEnd()) { |
| // Legacy syntax: -webkit-border-radius: l1 l2; is equivalent to |
| // border-radius: l1 / l2; |
| if (useLegacyParsing && i == 2) { |
| verticalRadii[0] = horizontalRadii[1]; |
| horizontalRadii[1] = nullptr; |
| } else { |
| complete4Sides(horizontalRadii); |
| for (unsigned i = 0; i < 4; ++i) |
| verticalRadii[i] = horizontalRadii[i]; |
| return true; |
| } |
| } else { |
| if (!consumeSlashIncludingWhitespace(range)) |
| return false; |
| for (i = 0; i < 4 && !range.atEnd(); ++i) { |
| verticalRadii[i] = |
| consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative); |
| if (!verticalRadii[i]) |
| return false; |
| } |
| if (!verticalRadii[0] || !range.atEnd()) |
| return false; |
| } |
| complete4Sides(horizontalRadii); |
| complete4Sides(verticalRadii); |
| return true; |
| } |
| |
| static CSSBasicShapeInsetValue* consumeBasicShapeInset( |
| CSSParserTokenRange& args, |
| const CSSParserContext& context) { |
| CSSBasicShapeInsetValue* shape = CSSBasicShapeInsetValue::create(); |
| CSSPrimitiveValue* top = |
| consumeLengthOrPercent(args, context.mode(), ValueRangeAll); |
| if (!top) |
| return nullptr; |
| CSSPrimitiveValue* right = |
| consumeLengthOrPercent(args, context.mode(), ValueRangeAll); |
| CSSPrimitiveValue* bottom = nullptr; |
| CSSPrimitiveValue* left = nullptr; |
| if (right) { |
| bottom = consumeLengthOrPercent(args, context.mode(), ValueRangeAll); |
| if (bottom) |
| left = consumeLengthOrPercent(args, context.mode(), ValueRangeAll); |
| } |
| if (left) |
| shape->updateShapeSize4Values(top, right, bottom, left); |
| else if (bottom) |
| shape->updateShapeSize3Values(top, right, bottom); |
| else if (right) |
| shape->updateShapeSize2Values(top, right); |
| else |
| shape->updateShapeSize1Value(top); |
| |
| if (consumeIdent<CSSValueRound>(args)) { |
| CSSValue* horizontalRadii[4] = {0}; |
| CSSValue* verticalRadii[4] = {0}; |
| if (!consumeRadii(horizontalRadii, verticalRadii, args, context.mode(), |
| false)) |
| return nullptr; |
| shape->setTopLeftRadius( |
| CSSValuePair::create(horizontalRadii[0], verticalRadii[0], |
| CSSValuePair::DropIdenticalValues)); |
| shape->setTopRightRadius( |
| CSSValuePair::create(horizontalRadii[1], verticalRadii[1], |
| CSSValuePair::DropIdenticalValues)); |
| shape->setBottomRightRadius( |
| CSSValuePair::create(horizontalRadii[2], verticalRadii[2], |
| CSSValuePair::DropIdenticalValues)); |
| shape->setBottomLeftRadius( |
| CSSValuePair::create(horizontalRadii[3], verticalRadii[3], |
| CSSValuePair::DropIdenticalValues)); |
| } |
| return shape; |
| } |
| |
| static CSSValue* consumeBasicShape(CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| CSSValue* shape = nullptr; |
| if (range.peek().type() != FunctionToken) |
| return nullptr; |
| CSSValueID id = range.peek().functionId(); |
| CSSParserTokenRange rangeCopy = range; |
| CSSParserTokenRange args = consumeFunction(rangeCopy); |
| if (id == CSSValueCircle) |
| shape = consumeBasicShapeCircle(args, context); |
| else if (id == CSSValueEllipse) |
| shape = consumeBasicShapeEllipse(args, context); |
| else if (id == CSSValuePolygon) |
| shape = consumeBasicShapePolygon(args, context); |
| else if (id == CSSValueInset) |
| shape = consumeBasicShapeInset(args, context); |
| if (!shape || !args.atEnd()) |
| return nullptr; |
| range = rangeCopy; |
| return shape; |
| } |
| |
| static CSSValue* consumeClipPath(CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| if (CSSURIValue* url = consumeUrl(range)) |
| return url; |
| return consumeBasicShape(range, context); |
| } |
| |
| static CSSValue* consumeShapeOutside(CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| if (CSSValue* imageValue = consumeImageOrNone(range, context)) |
| return imageValue; |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| if (CSSValue* boxValue = |
| consumeIdent<CSSValueContentBox, CSSValuePaddingBox, |
| CSSValueBorderBox, CSSValueMarginBox>(range)) |
| list->append(*boxValue); |
| if (CSSValue* shapeValue = consumeBasicShape(range, context)) { |
| list->append(*shapeValue); |
| if (list->length() < 2) { |
| if (CSSValue* boxValue = |
| consumeIdent<CSSValueContentBox, CSSValuePaddingBox, |
| CSSValueBorderBox, CSSValueMarginBox>(range)) |
| list->append(*boxValue); |
| } |
| } |
| if (!list->length()) |
| return nullptr; |
| return list; |
| } |
| |
| static CSSValue* consumeContentDistributionOverflowPosition( |
| CSSParserTokenRange& range) { |
| if (identMatches<CSSValueNormal, CSSValueBaseline, CSSValueLastBaseline>( |
| range.peek().id())) |
| return CSSContentDistributionValue::create( |
| CSSValueInvalid, range.consumeIncludingWhitespace().id(), |
| CSSValueInvalid); |
| |
| CSSValueID distribution = CSSValueInvalid; |
| CSSValueID position = CSSValueInvalid; |
| CSSValueID overflow = CSSValueInvalid; |
| do { |
| CSSValueID id = range.peek().id(); |
| if (identMatches<CSSValueSpaceBetween, CSSValueSpaceAround, |
| CSSValueSpaceEvenly, CSSValueStretch>(id)) { |
| if (distribution != CSSValueInvalid) |
| return nullptr; |
| distribution = id; |
| } else if (identMatches<CSSValueStart, CSSValueEnd, CSSValueCenter, |
| CSSValueFlexStart, CSSValueFlexEnd, CSSValueLeft, |
| CSSValueRight>(id)) { |
| if (position != CSSValueInvalid) |
| return nullptr; |
| position = id; |
| } else if (identMatches<CSSValueUnsafe, CSSValueSafe>(id)) { |
| if (overflow != CSSValueInvalid) |
| return nullptr; |
| overflow = id; |
| } else { |
| return nullptr; |
| } |
| range.consumeIncludingWhitespace(); |
| } while (!range.atEnd()); |
| |
| // The grammar states that we should have at least <content-distribution> or |
| // <content-position>. |
| if (position == CSSValueInvalid && distribution == CSSValueInvalid) |
| return nullptr; |
| |
| // The grammar states that <overflow-position> must be associated to |
| // <content-position>. |
| if (overflow != CSSValueInvalid && position == CSSValueInvalid) |
| return nullptr; |
| |
| return CSSContentDistributionValue::create(distribution, position, overflow); |
| } |
| |
| static CSSIdentifierValue* consumeBorderImageRepeatKeyword( |
| CSSParserTokenRange& range) { |
| return consumeIdent<CSSValueStretch, CSSValueRepeat, CSSValueSpace, |
| CSSValueRound>(range); |
| } |
| |
| static CSSValue* consumeBorderImageRepeat(CSSParserTokenRange& range) { |
| CSSIdentifierValue* horizontal = consumeBorderImageRepeatKeyword(range); |
| if (!horizontal) |
| return nullptr; |
| CSSIdentifierValue* vertical = consumeBorderImageRepeatKeyword(range); |
| if (!vertical) |
| vertical = horizontal; |
| return CSSValuePair::create(horizontal, vertical, |
| CSSValuePair::DropIdenticalValues); |
| } |
| |
| static CSSValue* consumeBorderImageSlice(CSSPropertyID property, |
| CSSParserTokenRange& range) { |
| bool fill = consumeIdent<CSSValueFill>(range); |
| CSSValue* slices[4] = {0}; |
| |
| for (size_t index = 0; index < 4; ++index) { |
| CSSPrimitiveValue* value = consumePercent(range, ValueRangeNonNegative); |
| if (!value) |
| value = consumeNumber(range, ValueRangeNonNegative); |
| if (!value) |
| break; |
| slices[index] = value; |
| } |
| if (!slices[0]) |
| return nullptr; |
| if (consumeIdent<CSSValueFill>(range)) { |
| if (fill) |
| return nullptr; |
| fill = true; |
| } |
| complete4Sides(slices); |
| // FIXME: For backwards compatibility, -webkit-border-image, |
| // -webkit-mask-box-image and -webkit-box-reflect have to do a fill by |
| // default. |
| // FIXME: What do we do with -webkit-box-reflect and -webkit-mask-box-image? |
| // Probably just have to leave them filling... |
| if (property == CSSPropertyWebkitBorderImage || |
| property == CSSPropertyWebkitMaskBoxImage || |
| property == CSSPropertyWebkitBoxReflect) |
| fill = true; |
| return CSSBorderImageSliceValue::create( |
| CSSQuadValue::create(slices[0], slices[1], slices[2], slices[3], |
| CSSQuadValue::SerializeAsQuad), |
| fill); |
| } |
| |
| static CSSValue* consumeBorderImageOutset(CSSParserTokenRange& range) { |
| CSSValue* outsets[4] = {0}; |
| |
| CSSValue* value = nullptr; |
| for (size_t index = 0; index < 4; ++index) { |
| value = consumeNumber(range, ValueRangeNonNegative); |
| if (!value) |
| value = consumeLength(range, HTMLStandardMode, ValueRangeNonNegative); |
| if (!value) |
| break; |
| outsets[index] = value; |
| } |
| if (!outsets[0]) |
| return nullptr; |
| complete4Sides(outsets); |
| return CSSQuadValue::create(outsets[0], outsets[1], outsets[2], outsets[3], |
| CSSQuadValue::SerializeAsQuad); |
| } |
| |
| static CSSValue* consumeBorderImageWidth(CSSParserTokenRange& range) { |
| CSSValue* widths[4] = {0}; |
| |
| CSSValue* value = nullptr; |
| for (size_t index = 0; index < 4; ++index) { |
| value = consumeNumber(range, ValueRangeNonNegative); |
| if (!value) |
| value = |
| consumeLengthOrPercent(range, HTMLStandardMode, ValueRangeNonNegative, |
| UnitlessQuirk::Forbid); |
| if (!value) |
| value = consumeIdent<CSSValueAuto>(range); |
| if (!value) |
| break; |
| widths[index] = value; |
| } |
| if (!widths[0]) |
| return nullptr; |
| complete4Sides(widths); |
| return CSSQuadValue::create(widths[0], widths[1], widths[2], widths[3], |
| CSSQuadValue::SerializeAsQuad); |
| } |
| |
| static bool consumeBorderImageComponents(CSSPropertyID property, |
| CSSParserTokenRange& range, |
| const CSSParserContext& context, |
| CSSValue*& source, |
| CSSValue*& slice, |
| CSSValue*& width, |
| CSSValue*& outset, |
| CSSValue*& repeat) { |
| do { |
| if (!source) { |
| source = consumeImageOrNone(range, context); |
| if (source) |
| continue; |
| } |
| if (!repeat) { |
| repeat = consumeBorderImageRepeat(range); |
| if (repeat) |
| continue; |
| } |
| if (!slice) { |
| slice = consumeBorderImageSlice(property, range); |
| if (slice) { |
| ASSERT(!width && !outset); |
| if (consumeSlashIncludingWhitespace(range)) { |
| width = consumeBorderImageWidth(range); |
| if (consumeSlashIncludingWhitespace(range)) { |
| outset = consumeBorderImageOutset(range); |
| if (!outset) |
| return false; |
| } else if (!width) { |
| return false; |
| } |
| } |
| } else { |
| return false; |
| } |
| } else { |
| return false; |
| } |
| } while (!range.atEnd()); |
| return true; |
| } |
| |
| static CSSValue* consumeWebkitBorderImage(CSSPropertyID property, |
| CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| CSSValue* source = nullptr; |
| CSSValue* slice = nullptr; |
| CSSValue* width = nullptr; |
| CSSValue* outset = nullptr; |
| CSSValue* repeat = nullptr; |
| if (consumeBorderImageComponents(property, range, context, source, slice, |
| width, outset, repeat)) |
| return createBorderImageValue(source, slice, width, outset, repeat); |
| return nullptr; |
| } |
| |
| static CSSValue* consumeReflect(CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| CSSIdentifierValue* direction = |
| consumeIdent<CSSValueAbove, CSSValueBelow, CSSValueLeft, CSSValueRight>( |
| range); |
| if (!direction) |
| return nullptr; |
| |
| CSSPrimitiveValue* offset = nullptr; |
| if (range.atEnd()) { |
| offset = CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::Pixels); |
| } else { |
| offset = consumeLengthOrPercent(range, context.mode(), ValueRangeAll, |
| UnitlessQuirk::Forbid); |
| if (!offset) |
| return nullptr; |
| } |
| |
| CSSValue* mask = nullptr; |
| if (!range.atEnd()) { |
| mask = |
| consumeWebkitBorderImage(CSSPropertyWebkitBoxReflect, range, context); |
| if (!mask) |
| return nullptr; |
| } |
| return CSSReflectValue::create(direction, offset, mask); |
| } |
| |
| static CSSValue* consumeFontSizeAdjust(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| return consumeNumber(range, ValueRangeNonNegative); |
| } |
| |
| static CSSValue* consumeImageOrientation(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueFromImage) |
| return consumeIdent(range); |
| if (range.peek().type() != NumberToken) { |
| CSSPrimitiveValue* angle = consumeAngle(range); |
| if (angle && angle->getDoubleValue() == 0) |
| return angle; |
| } |
| return nullptr; |
| } |
| |
| static CSSValue* consumeBackgroundBlendMode(CSSParserTokenRange& range) { |
| CSSValueID id = range.peek().id(); |
| if (id == CSSValueNormal || id == CSSValueOverlay || |
| (id >= CSSValueMultiply && id <= CSSValueLuminosity)) |
| return consumeIdent(range); |
| return nullptr; |
| } |
| |
| static CSSValue* consumeBackgroundAttachment(CSSParserTokenRange& range) { |
| return consumeIdent<CSSValueScroll, CSSValueFixed, CSSValueLocal>(range); |
| } |
| |
| static CSSValue* consumeBackgroundBox(CSSParserTokenRange& range) { |
| return consumeIdent<CSSValueBorderBox, CSSValuePaddingBox, |
| CSSValueContentBox>(range); |
| } |
| |
| static CSSValue* consumeBackgroundComposite(CSSParserTokenRange& range) { |
| return consumeIdentRange(range, CSSValueClear, CSSValuePlusLighter); |
| } |
| |
| static CSSValue* consumeMaskSourceType(CSSParserTokenRange& range) { |
| ASSERT(RuntimeEnabledFeatures::cssMaskSourceTypeEnabled()); |
| return consumeIdent<CSSValueAuto, CSSValueAlpha, CSSValueLuminance>(range); |
| } |
| |
| static CSSValue* consumePrefixedBackgroundBox(CSSPropertyID property, |
| CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| // The values 'border', 'padding' and 'content' are deprecated and do not |
| // apply to the version of the property that has the -webkit- prefix removed. |
| if (CSSValue* value = |
| consumeIdentRange(range, CSSValueBorder, CSSValuePaddingBox)) |
| return value; |
| if ((property == CSSPropertyWebkitBackgroundClip || |
| property == CSSPropertyWebkitMaskClip) && |
| range.peek().id() == CSSValueText) |
| return consumeIdent(range); |
| return nullptr; |
| } |
| |
| static CSSValue* consumeBackgroundSize(CSSPropertyID unresolvedProperty, |
| CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| if (identMatches<CSSValueContain, CSSValueCover>(range.peek().id())) |
| return consumeIdent(range); |
| |
| CSSValue* horizontal = consumeIdent<CSSValueAuto>(range); |
| if (!horizontal) |
| horizontal = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, |
| UnitlessQuirk::Forbid); |
| |
| CSSValue* vertical = nullptr; |
| if (!range.atEnd()) { |
| if (range.peek().id() == CSSValueAuto) // `auto' is the default |
| range.consumeIncludingWhitespace(); |
| else |
| vertical = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, |
| UnitlessQuirk::Forbid); |
| } else if (unresolvedProperty == CSSPropertyAliasWebkitBackgroundSize) { |
| // Legacy syntax: "-webkit-background-size: 10px" is equivalent to |
| // "background-size: 10px 10px". |
| vertical = horizontal; |
| } |
| if (!vertical) |
| return horizontal; |
| return CSSValuePair::create(horizontal, vertical, |
| CSSValuePair::KeepIdenticalValues); |
| } |
| |
| static CSSValueList* consumeGridAutoFlow(CSSParserTokenRange& range) { |
| CSSIdentifierValue* rowOrColumnValue = |
| consumeIdent<CSSValueRow, CSSValueColumn>(range); |
| CSSIdentifierValue* denseAlgorithm = consumeIdent<CSSValueDense>(range); |
| if (!rowOrColumnValue) { |
| rowOrColumnValue = consumeIdent<CSSValueRow, CSSValueColumn>(range); |
| if (!rowOrColumnValue && !denseAlgorithm) |
| return nullptr; |
| } |
| CSSValueList* parsedValues = CSSValueList::createSpaceSeparated(); |
| if (rowOrColumnValue) |
| parsedValues->append(*rowOrColumnValue); |
| if (denseAlgorithm) |
| parsedValues->append(*denseAlgorithm); |
| return parsedValues; |
| } |
| |
| static CSSValue* consumeBackgroundComponent(CSSPropertyID unresolvedProperty, |
| CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| switch (unresolvedProperty) { |
| case CSSPropertyBackgroundClip: |
| return consumeBackgroundBox(range); |
| case CSSPropertyBackgroundBlendMode: |
| return consumeBackgroundBlendMode(range); |
| case CSSPropertyBackgroundAttachment: |
| return consumeBackgroundAttachment(range); |
| case CSSPropertyBackgroundOrigin: |
| return consumeBackgroundBox(range); |
| case CSSPropertyWebkitMaskComposite: |
| return consumeBackgroundComposite(range); |
| case CSSPropertyMaskSourceType: |
| return consumeMaskSourceType(range); |
| case CSSPropertyWebkitBackgroundClip: |
| case CSSPropertyWebkitBackgroundOrigin: |
| case CSSPropertyWebkitMaskClip: |
| case CSSPropertyWebkitMaskOrigin: |
| return consumePrefixedBackgroundBox(unresolvedProperty, range, context); |
| case CSSPropertyBackgroundImage: |
| case CSSPropertyWebkitMaskImage: |
| return consumeImageOrNone(range, context); |
| case CSSPropertyBackgroundPositionX: |
| case CSSPropertyWebkitMaskPositionX: |
| return consumePositionX(range, context.mode()); |
| case CSSPropertyBackgroundPositionY: |
| case CSSPropertyWebkitMaskPositionY: |
| return consumePositionY(range, context.mode()); |
| case CSSPropertyBackgroundSize: |
| case CSSPropertyAliasWebkitBackgroundSize: |
| case CSSPropertyWebkitMaskSize: |
| return consumeBackgroundSize(unresolvedProperty, range, context.mode()); |
| case CSSPropertyBackgroundColor: |
| return consumeColor(range, context.mode()); |
| default: |
| break; |
| }; |
| return nullptr; |
| } |
| |
| static void addBackgroundValue(CSSValue*& list, CSSValue* value) { |
| if (list) { |
| if (!list->isBaseValueList()) { |
| CSSValue* firstValue = list; |
| list = CSSValueList::createCommaSeparated(); |
| toCSSValueList(list)->append(*firstValue); |
| } |
| toCSSValueList(list)->append(*value); |
| } else { |
| // To conserve memory we don't actually wrap a single value in a list. |
| list = value; |
| } |
| } |
| |
| static CSSValue* consumeCommaSeparatedBackgroundComponent( |
| CSSPropertyID unresolvedProperty, |
| CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| CSSValue* result = nullptr; |
| do { |
| CSSValue* value = |
| consumeBackgroundComponent(unresolvedProperty, range, context); |
| if (!value) |
| return nullptr; |
| addBackgroundValue(result, value); |
| } while (consumeCommaIncludingWhitespace(range)); |
| return result; |
| } |
| |
| static CSSIdentifierValue* consumeSelfPositionKeyword( |
| CSSParserTokenRange& range) { |
| CSSValueID id = range.peek().id(); |
| if (id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter || |
| id == CSSValueSelfStart || id == CSSValueSelfEnd || |
| id == CSSValueFlexStart || id == CSSValueFlexEnd || id == CSSValueLeft || |
| id == CSSValueRight) |
| return consumeIdent(range); |
| return nullptr; |
| } |
| |
| static CSSValue* consumeSelfPositionOverflowPosition( |
| CSSParserTokenRange& range) { |
| if (identMatches<CSSValueAuto, CSSValueNormal, CSSValueStretch, |
| CSSValueBaseline, CSSValueLastBaseline>(range.peek().id())) |
| return consumeIdent(range); |
| |
| CSSIdentifierValue* overflowPosition = |
| consumeIdent<CSSValueUnsafe, CSSValueSafe>(range); |
| CSSIdentifierValue* selfPosition = consumeSelfPositionKeyword(range); |
| if (!selfPosition) |
| return nullptr; |
| if (!overflowPosition) |
| overflowPosition = consumeIdent<CSSValueUnsafe, CSSValueSafe>(range); |
| if (overflowPosition) |
| return CSSValuePair::create(selfPosition, overflowPosition, |
| CSSValuePair::DropIdenticalValues); |
| return selfPosition; |
| } |
| |
| static CSSValue* consumeAlignItems(CSSParserTokenRange& range) { |
| // align-items property does not allow the 'auto' value. |
| if (identMatches<CSSValueAuto>(range.peek().id())) |
| return nullptr; |
| return consumeSelfPositionOverflowPosition(range); |
| } |
| |
| static CSSValue* consumeJustifyItems(CSSParserTokenRange& range) { |
| CSSParserTokenRange rangeCopy = range; |
| CSSIdentifierValue* legacy = consumeIdent<CSSValueLegacy>(rangeCopy); |
| CSSIdentifierValue* positionKeyword = |
| consumeIdent<CSSValueCenter, CSSValueLeft, CSSValueRight>(rangeCopy); |
| if (!legacy) |
| legacy = consumeIdent<CSSValueLegacy>(rangeCopy); |
| if (legacy && positionKeyword) { |
| range = rangeCopy; |
| return CSSValuePair::create(legacy, positionKeyword, |
| CSSValuePair::DropIdenticalValues); |
| } |
| return consumeSelfPositionOverflowPosition(range); |
| } |
| |
| static CSSValue* consumeFitContent(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| CSSParserTokenRange rangeCopy = range; |
| CSSParserTokenRange args = consumeFunction(rangeCopy); |
| CSSPrimitiveValue* length = consumeLengthOrPercent( |
| args, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Allow); |
| if (!length || !args.atEnd()) |
| return nullptr; |
| range = rangeCopy; |
| CSSFunctionValue* result = CSSFunctionValue::create(CSSValueFitContent); |
| result->append(*length); |
| return result; |
| } |
| |
| static CSSCustomIdentValue* consumeCustomIdentForGridLine( |
| CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueAuto || range.peek().id() == CSSValueSpan) |
| return nullptr; |
| return consumeCustomIdent(range); |
| } |
| |
| static CSSValue* consumeGridLine(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueAuto) |
| return consumeIdent(range); |
| |
| CSSIdentifierValue* spanValue = nullptr; |
| CSSCustomIdentValue* gridLineName = nullptr; |
| CSSPrimitiveValue* numericValue = consumeInteger(range); |
| if (numericValue) { |
| gridLineName = consumeCustomIdentForGridLine(range); |
| spanValue = consumeIdent<CSSValueSpan>(range); |
| } else { |
| spanValue = consumeIdent<CSSValueSpan>(range); |
| if (spanValue) { |
| numericValue = consumeInteger(range); |
| gridLineName = consumeCustomIdentForGridLine(range); |
| if (!numericValue) |
| numericValue = consumeInteger(range); |
| } else { |
| gridLineName = consumeCustomIdentForGridLine(range); |
| if (gridLineName) { |
| numericValue = consumeInteger(range); |
| spanValue = consumeIdent<CSSValueSpan>(range); |
| if (!spanValue && !numericValue) |
| return gridLineName; |
| } else { |
| return nullptr; |
| } |
| } |
| } |
| |
| if (spanValue && !numericValue && !gridLineName) |
| return nullptr; // "span" keyword alone is invalid. |
| if (spanValue && numericValue && numericValue->getIntValue() < 0) |
| return nullptr; // Negative numbers are not allowed for span. |
| if (numericValue && numericValue->getIntValue() == 0) |
| return nullptr; // An <integer> value of zero makes the declaration |
| // invalid. |
| |
| CSSValueList* values = CSSValueList::createSpaceSeparated(); |
| if (spanValue) |
| values->append(*spanValue); |
| if (numericValue) |
| values->append(*numericValue); |
| if (gridLineName) |
| values->append(*gridLineName); |
| ASSERT(values->length()); |
| return values; |
| } |
| |
| static bool isGridBreadthFixedSized(const CSSValue& value) { |
| if (value.isIdentifierValue()) { |
| CSSValueID valueID = toCSSIdentifierValue(value).getValueID(); |
| return !(valueID == CSSValueMinContent || valueID == CSSValueMaxContent || |
| valueID == CSSValueAuto); |
| } |
| |
| if (value.isPrimitiveValue()) { |
| return !toCSSPrimitiveValue(value).isFlex(); |
| } |
| |
| NOTREACHED(); |
| return true; |
| } |
| |
| static bool isGridTrackFixedSized(const CSSValue& value) { |
| if (value.isPrimitiveValue() || value.isIdentifierValue()) |
| return isGridBreadthFixedSized(value); |
| |
| DCHECK(value.isFunctionValue()); |
| auto& function = toCSSFunctionValue(value); |
| if (function.functionType() == CSSValueFitContent) |
| return false; |
| |
| const CSSValue& minValue = function.item(0); |
| const CSSValue& maxValue = function.item(1); |
| return isGridBreadthFixedSized(minValue) || isGridBreadthFixedSized(maxValue); |
| } |
| |
| static Vector<String> parseGridTemplateAreasColumnNames( |
| const String& gridRowNames) { |
| ASSERT(!gridRowNames.isEmpty()); |
| Vector<String> columnNames; |
| // Using StringImpl to avoid checks and indirection in every call to |
| // String::operator[]. |
| StringImpl& text = *gridRowNames.impl(); |
| |
| StringBuilder areaName; |
| for (unsigned i = 0; i < text.length(); ++i) { |
| if (isCSSSpace(text[i])) { |
| if (!areaName.isEmpty()) { |
| columnNames.append(areaName.toString()); |
| areaName.clear(); |
| } |
| continue; |
| } |
| if (text[i] == '.') { |
| if (areaName == ".") |
| continue; |
| if (!areaName.isEmpty()) { |
| columnNames.append(areaName.toString()); |
| areaName.clear(); |
| } |
| } else { |
| if (!isNameCodePoint(text[i])) |
| return Vector<String>(); |
| if (areaName == ".") { |
| columnNames.append(areaName.toString()); |
| areaName.clear(); |
| } |
| } |
| |
| areaName.append(text[i]); |
| } |
| |
| if (!areaName.isEmpty()) |
| columnNames.append(areaName.toString()); |
| |
| return columnNames; |
| } |
| |
| static bool parseGridTemplateAreasRow(const String& gridRowNames, |
| NamedGridAreaMap& gridAreaMap, |
| const size_t rowCount, |
| size_t& columnCount) { |
| if (gridRowNames.isEmpty() || gridRowNames.containsOnlyWhitespace()) |
| return false; |
| |
| Vector<String> columnNames = parseGridTemplateAreasColumnNames(gridRowNames); |
| if (rowCount == 0) { |
| columnCount = columnNames.size(); |
| if (columnCount == 0) |
| return false; |
| } else if (columnCount != columnNames.size()) { |
| // The declaration is invalid if all the rows don't have the number of |
| // columns. |
| return false; |
| } |
| |
| for (size_t currentColumn = 0; currentColumn < columnCount; ++currentColumn) { |
| const String& gridAreaName = columnNames[currentColumn]; |
| |
| // Unamed areas are always valid (we consider them to be 1x1). |
| if (gridAreaName == ".") |
| continue; |
| |
| size_t lookAheadColumn = currentColumn + 1; |
| while (lookAheadColumn < columnCount && |
| columnNames[lookAheadColumn] == gridAreaName) |
| lookAheadColumn++; |
| |
| NamedGridAreaMap::iterator gridAreaIt = gridAreaMap.find(gridAreaName); |
| if (gridAreaIt == gridAreaMap.end()) { |
| gridAreaMap.add( |
| gridAreaName, |
| GridArea(GridSpan::translatedDefiniteGridSpan(rowCount, rowCount + 1), |
| GridSpan::translatedDefiniteGridSpan(currentColumn, |
| lookAheadColumn))); |
| } else { |
| GridArea& gridArea = gridAreaIt->value; |
| |
| // The following checks test that the grid area is a single filled-in |
| // rectangle. |
| // 1. The new row is adjacent to the previously parsed row. |
| if (rowCount != gridArea.rows.endLine()) |
| return false; |
| |
| // 2. The new area starts at the same position as the previously parsed |
| // area. |
| if (currentColumn != gridArea.columns.startLine()) |
| return false; |
| |
| // 3. The new area ends at the same position as the previously parsed |
| // area. |
| if (lookAheadColumn != gridArea.columns.endLine()) |
| return false; |
| |
| gridArea.rows = GridSpan::translatedDefiniteGridSpan( |
| gridArea.rows.startLine(), gridArea.rows.endLine() + 1); |
| } |
| currentColumn = lookAheadColumn - 1; |
| } |
| |
| return true; |
| } |
| |
| static CSSValue* consumeGridBreadth(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| const CSSParserToken& token = range.peek(); |
| if (identMatches<CSSValueMinContent, CSSValueMaxContent, CSSValueAuto>( |
| token.id())) |
| return consumeIdent(range); |
| if (token.type() == DimensionToken && |
| token.unitType() == CSSPrimitiveValue::UnitType::Fraction) { |
| if (range.peek().numericValue() < 0) |
| return nullptr; |
| return CSSPrimitiveValue::create( |
| range.consumeIncludingWhitespace().numericValue(), |
| CSSPrimitiveValue::UnitType::Fraction); |
| } |
| return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, |
| UnitlessQuirk::Allow); |
| } |
| |
| static CSSValue* consumeGridTrackSize(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| const CSSParserToken& token = range.peek(); |
| if (identMatches<CSSValueAuto>(token.id())) |
| return consumeIdent(range); |
| |
| if (token.functionId() == CSSValueMinmax) { |
| CSSParserTokenRange rangeCopy = range; |
| CSSParserTokenRange args = consumeFunction(rangeCopy); |
| CSSValue* minTrackBreadth = consumeGridBreadth(args, cssParserMode); |
| if (!minTrackBreadth || (minTrackBreadth->isPrimitiveValue() && |
| toCSSPrimitiveValue(minTrackBreadth)->isFlex()) || |
| !consumeCommaIncludingWhitespace(args)) |
| return nullptr; |
| CSSValue* maxTrackBreadth = consumeGridBreadth(args, cssParserMode); |
| if (!maxTrackBreadth || !args.atEnd()) |
| return nullptr; |
| range = rangeCopy; |
| CSSFunctionValue* result = CSSFunctionValue::create(CSSValueMinmax); |
| result->append(*minTrackBreadth); |
| result->append(*maxTrackBreadth); |
| return result; |
| } |
| |
| if (token.functionId() == CSSValueFitContent) |
| return consumeFitContent(range, cssParserMode); |
| |
| return consumeGridBreadth(range, cssParserMode); |
| } |
| |
| // Appends to the passed in CSSGridLineNamesValue if any, otherwise creates a |
| // new one. |
| static CSSGridLineNamesValue* consumeGridLineNames( |
| CSSParserTokenRange& range, |
| CSSGridLineNamesValue* lineNames = nullptr) { |
| CSSParserTokenRange rangeCopy = range; |
| if (rangeCopy.consumeIncludingWhitespace().type() != LeftBracketToken) |
| return nullptr; |
| if (!lineNames) |
| lineNames = CSSGridLineNamesValue::create(); |
| while (CSSCustomIdentValue* lineName = |
| consumeCustomIdentForGridLine(rangeCopy)) |
| lineNames->append(*lineName); |
| if (rangeCopy.consumeIncludingWhitespace().type() != RightBracketToken) |
| return nullptr; |
| range = rangeCopy; |
| return lineNames; |
| } |
| |
| static bool consumeGridTrackRepeatFunction(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode, |
| CSSValueList& list, |
| bool& isAutoRepeat, |
| bool& allTracksAreFixedSized) { |
| CSSParserTokenRange args = consumeFunction(range); |
| // The number of repetitions for <auto-repeat> is not important at parsing |
| // level because it will be computed later, let's set it to 1. |
| size_t repetitions = 1; |
| isAutoRepeat = |
| identMatches<CSSValueAutoFill, CSSValueAutoFit>(args.peek().id()); |
| CSSValueList* repeatedValues; |
| if (isAutoRepeat) { |
| repeatedValues = |
| CSSGridAutoRepeatValue::create(args.consumeIncludingWhitespace().id()); |
| } else { |
| // TODO(rob.buis): a consumeIntegerRaw would be more efficient here. |
| CSSPrimitiveValue* repetition = consumePositiveInteger(args); |
| if (!repetition) |
| return false; |
| repetitions = |
| clampTo<size_t>(repetition->getDoubleValue(), 0, kGridMaxTracks); |
| repeatedValues = CSSValueList::createSpaceSeparated(); |
| } |
| if (!consumeCommaIncludingWhitespace(args)) |
| return false; |
| CSSGridLineNamesValue* lineNames = consumeGridLineNames(args); |
| if (lineNames) |
| repeatedValues->append(*lineNames); |
| |
| size_t numberOfTracks = 0; |
| while (!args.atEnd()) { |
| CSSValue* trackSize = consumeGridTrackSize(args, cssParserMode); |
| if (!trackSize) |
| return false; |
| if (allTracksAreFixedSized) |
| allTracksAreFixedSized = isGridTrackFixedSized(*trackSize); |
| repeatedValues->append(*trackSize); |
| ++numberOfTracks; |
| lineNames = consumeGridLineNames(args); |
| if (lineNames) |
| repeatedValues->append(*lineNames); |
| } |
| // We should have found at least one <track-size> or else it is not a valid |
| // <track-list>. |
| if (!numberOfTracks) |
| return false; |
| |
| if (isAutoRepeat) { |
| list.append(*repeatedValues); |
| } else { |
| // We clamp the repetitions to a multiple of the repeat() track list's size, |
| // while staying below the max grid size. |
| repetitions = std::min(repetitions, kGridMaxTracks / numberOfTracks); |
| for (size_t i = 0; i < repetitions; ++i) { |
| for (size_t j = 0; j < repeatedValues->length(); ++j) |
| list.append(repeatedValues->item(j)); |
| } |
| } |
| return true; |
| } |
| |
| enum TrackListType { GridTemplate, GridTemplateNoRepeat, GridAuto }; |
| |
| static CSSValue* consumeGridTrackList(CSSParserTokenRange& range, |
| CSSParserMode cssParserMode, |
| TrackListType trackListType) { |
| bool allowGridLineNames = trackListType != GridAuto; |
| CSSValueList* values = CSSValueList::createSpaceSeparated(); |
| CSSGridLineNamesValue* lineNames = consumeGridLineNames(range); |
| if (lineNames) { |
| if (!allowGridLineNames) |
| return nullptr; |
| values->append(*lineNames); |
| } |
| |
| bool allowRepeat = trackListType == GridTemplate; |
| bool seenAutoRepeat = false; |
| bool allTracksAreFixedSized = true; |
| do { |
| bool isAutoRepeat; |
| if (range.peek().functionId() == CSSValueRepeat) { |
| if (!allowRepeat) |
| return nullptr; |
| if (!consumeGridTrackRepeatFunction(range, cssParserMode, *values, |
| isAutoRepeat, allTracksAreFixedSized)) |
| return nullptr; |
| if (isAutoRepeat && seenAutoRepeat) |
| return nullptr; |
| seenAutoRepeat = seenAutoRepeat || isAutoRepeat; |
| } else if (CSSValue* value = consumeGridTrackSize(range, cssParserMode)) { |
| if (allTracksAreFixedSized) |
| allTracksAreFixedSized = isGridTrackFixedSized(*value); |
| values->append(*value); |
| } else { |
| return nullptr; |
| } |
| if (seenAutoRepeat && !allTracksAreFixedSized) |
| return nullptr; |
| lineNames = consumeGridLineNames(range); |
| if (lineNames) { |
| if (!allowGridLineNames) |
| return nullptr; |
| values->append(*lineNames); |
| } |
| } while (!range.atEnd() && range.peek().type() != DelimiterToken); |
| return values; |
| } |
| |
| static CSSValue* consumeGridTemplatesRowsOrColumns( |
| CSSParserTokenRange& range, |
| CSSParserMode cssParserMode) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| return consumeGridTrackList(range, cssParserMode, GridTemplate); |
| } |
| |
| static CSSValue* consumeGridTemplateAreas(CSSParserTokenRange& range) { |
| if (range.peek().id() == CSSValueNone) |
| return consumeIdent(range); |
| |
| NamedGridAreaMap gridAreaMap; |
| size_t rowCount = 0; |
| size_t columnCount = 0; |
| |
| while (range.peek().type() == StringToken) { |
| if (!parseGridTemplateAreasRow( |
| range.consumeIncludingWhitespace().value().toString(), gridAreaMap, |
| rowCount, columnCount)) |
| return nullptr; |
| ++rowCount; |
| } |
| |
| if (rowCount == 0) |
| return nullptr; |
| ASSERT(columnCount); |
| return CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount); |
| } |
| |
| static void countKeywordOnlyPropertyUsage(CSSPropertyID property, |
| UseCounter* counter, |
| CSSValueID valueID) { |
| if (!counter) |
| return; |
| switch (property) { |
| case CSSPropertyWebkitAppearance: |
| if (valueID == CSSValueNone) { |
| counter->count(UseCounter::CSSValueAppearanceNone); |
| } else { |
| counter->count(UseCounter::CSSValueAppearanceNotNone); |
| if (valueID == CSSValueButton) |
| counter->count(UseCounter::CSSValueAppearanceButton); |
| else if (valueID == CSSValueCaret) |
| counter->count(UseCounter::CSSValueAppearanceCaret); |
| else if (valueID == CSSValueCheckbox) |
| counter->count(UseCounter::CSSValueAppearanceCheckbox); |
| else if (valueID == CSSValueMenulist) |
| counter->count(UseCounter::CSSValueAppearanceMenulist); |
| else if (valueID == CSSValueMenulistButton) |
| counter->count(UseCounter::CSSValueAppearanceMenulistButton); |
| else if (valueID == CSSValueListbox) |
| counter->count(UseCounter::CSSValueAppearanceListbox); |
| else if (valueID == CSSValueRadio) |
| counter->count(UseCounter::CSSValueAppearanceRadio); |
| else if (valueID == CSSValueSearchfield) |
| counter->count(UseCounter::CSSValueAppearanceSearchField); |
| else if (valueID == CSSValueTextfield) |
| counter->count(UseCounter::CSSValueAppearanceTextField); |
| else |
| counter->count(UseCounter::CSSValueAppearanceOthers); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| const CSSValue* CSSPropertyParser::parseSingleValue( |
| CSSPropertyID unresolvedProperty, |
| CSSPropertyID currentShorthand) { |
| CSSPropertyID property = resolveCSSPropertyID(unresolvedProperty); |
| if (CSSParserFastPaths::isKeywordPropertyID(property)) { |
| if (!CSSParserFastPaths::isValidKeywordPropertyAndValue( |
| property, m_range.peek().id(), m_context.mode())) |
| return nullptr; |
| countKeywordOnlyPropertyUsage(property, m_context.useCounter(), |
| m_range.peek().id()); |
| return consumeIdent(m_range); |
| } |
| switch (property) { |
| case CSSPropertyWillChange: |
| return consumeWillChange(m_range); |
| case CSSPropertyPage: |
| return consumePage(m_range); |
| case CSSPropertyQuotes: |
| return consumeQuotes(m_range); |
| case CSSPropertyWebkitHighlight: |
| return consumeWebkitHighlight(m_range); |
| case CSSPropertyFontVariantCaps: |
| return consumeFontVariantCaps(m_range); |
| case CSSPropertyFontVariantLigatures: |
| return consumeFontVariantLigatures(m_range); |
| case CSSPropertyFontVariantNumeric: |
| return consumeFontVariantNumeric(m_range); |
| case CSSPropertyFontFeatureSettings: |
| return consumeFontFeatureSettings(m_range); |
| case CSSPropertyFontFamily: |
| return consumeFontFamily(m_range); |
| case CSSPropertyFontWeight: |
| return consumeFontWeight(m_range); |
| case CSSPropertyLetterSpacing: |
| case CSSPropertyWordSpacing: |
| return consumeSpacing(m_range, m_context.mode()); |
| case CSSPropertyTabSize: |
| return consumeTabSize(m_range, m_context.mode()); |
| case CSSPropertyTextSizeAdjust: |
| return consumeTextSizeAdjust(m_range, m_context.mode()); |
| case CSSPropertyFontSize: |
| return consumeFontSize(m_range, m_context.mode(), UnitlessQuirk::Allow); |
| case CSSPropertyLineHeight: |
| return consumeLineHeight(m_range, m_context.mode()); |
| case CSSPropertyRotate: |
| return consumeRotation(m_range); |
| case CSSPropertyScale: |
| return consumeScale(m_range); |
| case CSSPropertyTranslate: |
| return consumeTranslate(m_range, m_context.mode()); |
| case CSSPropertyWebkitBorderHorizontalSpacing: |
| case CSSPropertyWebkitBorderVerticalSpacing: |
| return consumeLength(m_range, m_context.mode(), ValueRangeNonNegative); |
| case CSSPropertyCounterIncrement: |
| case CSSPropertyCounterReset: |
| return consumeCounter(m_range, |
| property == CSSPropertyCounterIncrement ? 1 : 0); |
| case CSSPropertySize: |
| return consumeSize(m_range, m_context.mode()); |
| case CSSPropertySnapHeight: |
| return consumeSnapHeight(m_range, m_context.mode()); |
| case CSSPropertyTextIndent: |
| return consumeTextIndent(m_range, m_context.mode()); |
| case CSSPropertyMaxWidth: |
| case CSSPropertyMaxHeight: |
| return consumeMaxWidthOrHeight(m_range, m_context, UnitlessQuirk::Allow); |
| case CSSPropertyWebkitMaxLogicalWidth: |
| case CSSPropertyWebkitMaxLogicalHeight: |
| return consumeMaxWidthOrHeight(m_range, m_context); |
| case CSSPropertyMinWidth: |
| case CSSPropertyMinHeight: |
| case CSSPropertyWidth: |
| case CSSPropertyHeight: |
| return consumeWidthOrHeight(m_range, m_context, UnitlessQuirk::Allow); |
| case CSSPropertyWebkitMinLogicalWidth: |
| case CSSPropertyWebkitMinLogicalHeight: |
| case CSSPropertyWebkitLogicalWidth: |
| case CSSPropertyWebkitLogicalHeight: |
| return consumeWidthOrHeight(m_range, m_context); |
| case CSSPropertyMarginTop: |
| case CSSPropertyMarginRight: |
| case CSSPropertyMarginBottom: |
| case CSSPropertyMarginLeft: |
| case CSSPropertyBottom: |
| case CSSPropertyLeft: |
| case CSSPropertyRight: |
| case CSSPropertyTop: |
| return consumeMarginOrOffset(m_range, m_context.mode(), |
| UnitlessQuirk::Allow); |
| case CSSPropertyWebkitMarginStart: |
| case CSSPropertyWebkitMarginEnd: |
| case CSSPropertyWebkitMarginBefore: |
| case CSSPropertyWebkitMarginAfter: |
| return consumeMarginOrOffset(m_range, m_context.mode(), |
| UnitlessQuirk::Forbid); |
| case CSSPropertyPaddingTop: |
| case CSSPropertyPaddingRight: |
| case CSSPropertyPaddingBottom: |
| case CSSPropertyPaddingLeft: |
| return consumeLengthOrPercent(m_range, m_context.mode(), |
| ValueRangeNonNegative, |
| UnitlessQuirk::Allow); |
| case CSSPropertyWebkitPaddingStart: |
| case CSSPropertyWebkitPaddingEnd: |
| case CSSPropertyWebkitPaddingBefore: |
| case CSSPropertyWebkitPaddingAfter: |
| return consumeLengthOrPercent(m_range, m_context.mode(), |
| ValueRangeNonNegative, |
| UnitlessQuirk::Forbid); |
| case CSSPropertyClip: |
| return consumeClip(m_range, m_context.mode()); |
| case CSSPropertyTouchAction: |
| return consumeTouchAction(m_range); |
| case CSSPropertyScrollSnapDestination: |
| case CSSPropertyObjectPosition: |
| case CSSPropertyPerspectiveOrigin: |
| return consumePosition(m_range, m_context.mode(), UnitlessQuirk::Forbid); |
| case CSSPropertyWebkitLineClamp: |
| return consumeLineClamp(m_range); |
| case CSSPropertyWebkitFontSizeDelta: |
| return consumeLength(m_range, m_context.mode(), ValueRangeAll, |
| UnitlessQuirk::Allow); |
| case CSSPropertyWebkitHyphenateCharacter: |
| case CSSPropertyWebkitLocale: |
| return consumeLocale(m_range); |
| case CSSPropertyColumnWidth: |
| return consumeColumnWidth(m_range); |
| case CSSPropertyColumnCount: |
| return consumeColumnCount(m_range); |
| case CSSPropertyColumnGap: |
| return consumeColumnGap(m_range, m_context.mode()); |
| case CSSPropertyColumnSpan: |
| return consumeColumnSpan(m_range); |
| case CSSPropertyZoom: |
| return consumeZoom(m_range, m_context); |
| case CSSPropertyAnimationDelay: |
| case CSSPropertyTransitionDelay: |
| case CSSPropertyAnimationDirection: |
| case CSSPropertyAnimationDuration: |
| case CSSPropertyTransitionDuration: |
| case CSSPropertyAnimationFillMode: |
| case CSSPropertyAnimationIterationCount: |
| case CSSPropertyAnimationName: |
| case CSSPropertyAnimationPlayState: |
| case CSSPropertyTransitionProperty: |
| case CSSPropertyAnimationTimingFunction: |
| case CSSPropertyTransitionTimingFunction: |
| return consumeAnimationPropertyList( |
| property, m_range, m_context, |
| unresolvedProperty == CSSPropertyAliasWebkitAnimationName); |
| case CSSPropertyGridColumnGap: |
| case CSSPropertyGridRowGap: |
| return consumeLengthOrPercent(m_range, m_context.mode(), |
| ValueRangeNonNegative); |
| case CSSPropertyShapeMargin: |
| return consumeLengthOrPercent(m_range, m_context.mode(), |
| ValueRangeNonNegative); |
| case CSSPropertyShapeImageThreshold: |
| return consumeNumber(m_range, ValueRangeAll); |
| case CSSPropertyWebkitBoxOrdinalGroup: |
| case CSSPropertyOrphans: |
| case CSSPropertyWidows: |
| return consumePositiveInteger(m_range); |
| case CSSPropertyTextDecorationColor: |
| ASSERT(RuntimeEnabledFeatures::css3TextDecorationsEnabled()); |
| return consumeColor(m_range, m_context.mode()); |
| case CSSPropertyWebkitTextStrokeWidth: |
| return consumeTextStrokeWidth(m_range, m_context.mode()); |
| case CSSPropertyWebkitTextFillColor: |
| case CSSPropertyWebkitTapHighlightColor: |
| case CSSPropertyWebkitTextEmphasisColor: |
| case CSSPropertyWebkitBorderStartColor: |
| case CSSPropertyWebkitBorderEndColor: |
| case CSSPropertyWebkitBorderBeforeColor: |
| case CSSPropertyWebkitBorderAfterColor: |
| case CSSPropertyWebkitTextStrokeColor: |
| case CSSPropertyStopColor: |
| case CSSPropertyFloodColor: |
| case CSSPropertyLightingColor: |
| case CSSPropertyColumnRuleColor: |
| return consumeColor(m_range, m_context.mode()); |
| case CSSPropertyColor: |
| case CSSPropertyBackgroundColor: |
| return consumeColor(m_range, m_context.mode(), inQuirksMode()); |
| case CSSPropertyWebkitBorderStartWidth: |
| case CSSPropertyWebkitBorderEndWidth: |
| case CSSPropertyWebkitBorderBeforeWidth: |
| case CSSPropertyWebkitBorderAfterWidth: |
| return consumeBorderWidth(m_range, m_context.mode(), |
| UnitlessQuirk::Forbid); |
| case CSSPropertyBorderBottomColor: |
| case CSSPropertyBorderLeftColor: |
| case CSSPropertyBorderRightColor: |
| case CSSPropertyBorderTopColor: { |
| bool allowQuirkyColors = |
| inQuirksMode() && (currentShorthand == CSSPropertyInvalid || |
| currentShorthand == CSSPropertyBorderColor); |
| return consumeColor(m_range, m_context.mode(), allowQuirkyColors); |
| } |
| case CSSPropertyBorderBottomWidth: |
| case CSSPropertyBorderLeftWidth: |
| case CSSPropertyBorderRightWidth: |
| case CSSPropertyBorderTopWidth: { |
| bool allowQuirkyLengths = |
| inQuirksMode() && (currentShorthand == CSSPropertyInvalid || |
| currentShorthand == CSSPropertyBorderWidth); |
| UnitlessQuirk unitless = |
| allowQuirkyLengths ? UnitlessQuirk::Allow : UnitlessQuirk::Forbid; |
| return consumeBorderWidth(m_range, m_context.mode(), unitless); |
| } |
| case CSSPropertyZIndex: |
| return consumeZIndex(m_range); |
| case CSSPropertyTextShadow: // CSS2 property, dropped in CSS2.1, back in |
| // CSS3, so treat as CSS3 |
| case CSSPropertyBoxShadow: |
| return consumeShadow(m_range, m_context.mode(), |
| property == CSSPropertyBoxShadow); |
| case CSSPropertyFilter: |
| case CSSPropertyBackdropFilter: |
| return consumeFilter(m_range, m_context); |
| case CSSPropertyTextDecoration: |
| ASSERT(!RuntimeEnabledFeatures::css3TextDecorationsEnabled()); |
| // fallthrough |
| case CSSPropertyWebkitTextDecorationsInEffect: |
| case CSSPropertyTextDecorationLine: |
| return consumeTextDecorationLine(m_range); |
| case CSSPropertyOffsetAnchor: |
| return consumeOffsetAnchor(m_range, m_context.mode()); |
| case CSSPropertyOffsetPosition: |
| return consumeOffsetPosition(m_range, m_context.mode(), |
| m_context.useCounter()); |
| case CSSPropertyD: |
| return consumePathOrNone(m_range); |
| case CSSPropertyOffsetPath: |
| return consumeOffsetPath( |
| m_range, m_context.useCounter(), |
| currentShorthand == CSSPropertyMotion || |
| unresolvedProperty == CSSPropertyAliasMotionPath); |
| case CSSPropertyOffsetDistance: |
| return consumeLengthOrPercent(m_range, m_context.mode(), ValueRangeAll); |
| case CSSPropertyOffsetRotation: |
| return consumeOffsetRotation(m_range); |
| case CSSPropertyWebkitTextEmphasisStyle: |
| return consumeTextEmphasisStyle(m_range); |
| case CSSPropertyOutlineColor: |
| return consumeOutlineColor(m_range, m_context.mode()); |
| case CSSPropertyOutlineOffset: |
| return consumeLength(m_range, m_context.mode(), ValueRangeAll); |
| case CSSPropertyOutlineWidth: |
| return consumeLineWidth(m_range, m_context.mode(), UnitlessQuirk::Forbid); |
| case CSSPropertyTransform: |
| return consumeTransform( |
| m_range, m_context.mode(), |
| unresolvedProperty == CSSPropertyAliasWebkitTransform); |
| case CSSPropertyWebkitTransformOriginX: |
| case CSSPropertyWebkitPerspectiveOriginX: |
| return consumePositionX(m_range, m_context.mode()); |
| case CSSPropertyWebkitTransformOriginY: |
| case CSSPropertyWebkitPerspectiveOriginY: |
| return consumePositionY(m_range, m_context.mode()); |
| case CSSPropertyWebkitTransformOriginZ: |
| return consumeLength(m_range, m_context.mode(), ValueRangeAll); |
| case CSSPropertyFill: |
| case CSSPropertyStroke: |
| return consumePaintStroke(m_range, m_context.mode()); |
| case CSSPropertyPaintOrder: |
| return consumePaintOrder(m_range); |
| case CSSPropertyMarkerStart: |
| case CSSPropertyMarkerMid: |
| case CSSPropertyMarkerEnd: |
| case CSSPropertyMask: |
| return consumeNoneOrURI(m_range); |
| case CSSPropertyFlexBasis: |
| return consumeFlexBasis(m_range, m_context.mode()); |
| case CSSPropertyFlexGrow: |
| case CSSPropertyFlexShrink: |
| return consumeNumber(m_range, ValueRangeNonNegative); |
| case CSSPropertyStrokeDasharray: |
| return consumeStrokeDasharray(m_range); |
| case CSSPropertyColumnRuleWidth: |
| return consumeColumnRuleWidth(m_range, m_context.mode()); |
| case CSSPropertyStrokeOpacity: |
| case CSSPropertyFillOpacity: |
| case CSSPropertyStopOpacity: |
| case CSSPropertyFloodOpacity: |
| case CSSPropertyOpacity: |
| case CSSPropertyWebkitBoxFlex: |
| return consumeNumber(m_range, ValueRangeAll); |
| case CSSPropertyBaselineShift: |
| return consumeBaselineShift(m_range); |
| case CSSPropertyStrokeMiterlimit: |
| return consumeNumber(m_range, ValueRangeNonNegative); |
| case CSSPropertyStrokeWidth: |
| case CSSPropertyStrokeDashoffset: |
| case CSSPropertyCx: |
| case CSSPropertyCy: |
| case CSSPropertyX: |
| case CSSPropertyY: |
| case CSSPropertyR: |
| return consumeLengthOrPercent(m_range, SVGAttributeMode, ValueRangeAll, |
| UnitlessQuirk::Forbid); |
| case CSSPropertyRx: |
| case CSSPropertyRy: |
| return consumeRxOrRy(m_range); |
| case CSSPropertyCursor: |
| return consumeCursor(m_range, m_context, inQuirksMode()); |
| case CSSPropertyContain: |
| return consumeContain(m_range); |
| case CSSPropertyTransformOrigin: |
| return consumeTransformOrigin(m_range, m_context.mode(), |
| UnitlessQuirk::Forbid); |
| case CSSPropertyContent: |
| return consumeContent(m_range, m_context); |
| case CSSPropertyListStyleImage: |
| case CSSPropertyBorderImageSource: |
| case CSSPropertyWebkitMaskBoxImageSource: |
| return consumeImageOrNone(m_range, m_context); |
| case CSSPropertyPerspective: |
| return consumePerspective(m_range, m_context.mode(), unresolvedProperty); |
| case CSSPropertyScrollSnapCoordinate: |
| return consumeScrollSnapCoordinate(m_range, m_context.mode()); |
| case CSSPropertyScrollSnapPointsX: |
| case CSSPropertyScrollSnapPointsY: |
| return consumeScrollSnapPoints(m_range, m_context.mode()); |
| case CSSPropertyBorderTopRightRadius: |
| case CSSPropertyBorderTopLeftRadius: |
| case CSSPropertyBorderBottomLeftRadius: |
| case CSSPropertyBorderBottomRightRadius: |
| return consumeBorderRadiusCorner(m_range, m_context.mode()); |
| case CSSPropertyWebkitBoxFlexGroup: |
| return consumeInteger(m_range, 0); |
| case CSSPropertyOrder: |
| return consumeInteger(m_range); |
| case CSSPropertyTextUnderlinePosition: |
| // auto | [ under || [ left | right ] ], but we only support auto | under |
| // for now |
| ASSERT(RuntimeEnabledFeatures::css3TextDecorationsEnabled()); |
| return consumeIdent<CSSValueAuto, CSSValueUnder>(m_range); |
| case CSSPropertyVerticalAlign: |
| return consumeVerticalAlign(m_range, m_context.mode()); |
| case CSSPropertyShapeOutside: |
| return consumeShapeOutside(m_range, m_context); |
| case CSSPropertyClipPath: |
| return consumeClipPath(m_range, m_context); |
| case CSSPropertyJustifyContent: |
| case CSSPropertyAlignContent: |
| ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled()); |
| return consumeContentDistributionOverflowPosition(m_range); |
| case CSSPropertyBorderImageRepeat: |
| case CSSPropertyWebkitMaskBoxImageRepeat: |
| return consumeBorderImageRepeat(m_range); |
| case CSSPropertyBorderImageSlice: |
| case CSSPropertyWebkitMaskBoxImageSlice: |
| return consumeBorderImageSlice(property, m_range); |
| case CSSPropertyBorderImageOutset: |
| case CSSPropertyWebkitMaskBoxImageOutset: |
| return consumeBorderImageOutset(m_range); |
| case CSSPropertyBorderImageWidth: |
| case CSSPropertyWebkitMaskBoxImageWidth: |
| return consumeBorderImageWidth(m_range); |
| case CSSPropertyWebkitBorderImage: |
| return consumeWebkitBorderImage(property, m_range, m_context); |
| case CSSPropertyWebkitBoxReflect: |
| return consumeReflect(m_range, m_context); |
| case CSSPropertyFontSizeAdjust: |
| ASSERT(RuntimeEnabledFeatures::cssFontSizeAdjustEnabled()); |
| return consumeFontSizeAdjust(m_range); |
| case CSSPropertyImageOrientation: |
| ASSERT(RuntimeEnabledFeatures::imageOrientationEnabled()); |
| return consumeImageOrientation(m_range); |
| case CSSPropertyBackgroundAttachment: |
| case CSSPropertyBackgroundBlendMode: |
| case CSSPropertyBackgroundClip: |
| case CSSPropertyBackgroundImage: |
| case CSSPropertyBackgroundOrigin: |
| case CSSPropertyBackgroundPositionX: |
| case CSSPropertyBackgroundPositionY: |
| case CSSPropertyBackgroundSize: |
| case CSSPropertyMaskSourceType: |
| case CSSPropertyWebkitBackgroundClip: |
| case CSSPropertyWebkitBackgroundOrigin: |
| case CSSPropertyWebkitMaskClip: |
| case CSSPropertyWebkitMaskComposite: |
| case CSSPropertyWebkitMaskImage: |
| case CSSPropertyWebkitMaskOrigin: |
| case CSSPropertyWebkitMaskPositionX: |
| case CSSPropertyWebkitMaskPositionY: |
| case CSSPropertyWebkitMaskSize: |
| return consumeCommaSeparatedBackgroundComponent(unresolvedProperty, |
| m_range, m_context); |
| case CSSPropertyWebkitMaskRepeatX: |
| case CSSPropertyWebkitMaskRepeatY: |
| return nullptr; |
| case CSSPropertyAlignItems: |
| DCHECK(RuntimeEnabledFeatures::cssGridLayoutEnabled()); |
| return consumeAlignItems(m_range); |
| case CSSPropertyJustifySelf: |
| case CSSPropertyAlignSelf: |
| ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled()); |
| return consumeSelfPositionOverflowPosition(m_range); |
| case CSSPropertyJustifyItems: |
| ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled()); |
| return consumeJustifyItems(m_range); |
| case CSSPropertyGridColumnEnd: |
| case CSSPropertyGridColumnStart: |
| case CSSPropertyGridRowEnd: |
| case CSSPropertyGridRowStart: |
| ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled()); |
| return consumeGridLine(m_range); |
| case CSSPropertyGridAutoColumns: |
| case CSSPropertyGridAutoRows: |
| ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled()); |
| return consumeGridTrackList(m_range, m_context.mode(), GridAuto); |
| case CSSPropertyGridTemplateColumns: |
| case CSSPropertyGridTemplateRows: |
| ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled()); |
| return consumeGridTemplatesRowsOrColumns(m_range, m_context.mode()); |
| case CSSPropertyGridTemplateAreas: |
| ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled()); |
| return consumeGridTemplateAreas(m_range); |
| case CSSPropertyGridAutoFlow: |
| ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled()); |
| return consumeGridAutoFlow(m_range); |
| default: |
| return nullptr; |
| } |
| } |
| |
| static CSSIdentifierValue* consumeFontDisplay(CSSParserTokenRange& range) { |
| return consumeIdent<CSSValueAuto, CSSValueBlock, CSSValueSwap, |
| CSSValueFallback, CSSValueOptional>(range); |
| } |
| |
| static CSSValueList* consumeFontFaceUnicodeRange(CSSParserTokenRange& range) { |
| CSSValueList* values = CSSValueList::createCommaSeparated(); |
| |
| do { |
| const CSSParserToken& token = range.consumeIncludingWhitespace(); |
| if (token.type() != UnicodeRangeToken) |
| return nullptr; |
| |
| UChar32 start = token.unicodeRangeStart(); |
| UChar32 end = token.unicodeRangeEnd(); |
| if (start > end) |
| return nullptr; |
| values->append(*CSSUnicodeRangeValue::create(start, end)); |
| } while (consumeCommaIncludingWhitespace(range)); |
| |
| return values; |
| } |
| |
| static CSSValue* consumeFontFaceSrcURI(CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| String url = consumeUrlAsStringView(range).toString(); |
| if (url.isNull()) |
| return nullptr; |
| CSSFontFaceSrcValue* uriValue( |
| CSSFontFaceSrcValue::create(url, context.completeURL(url), |
| context.shouldCheckContentSecurityPolicy())); |
| uriValue->setReferrer(context.referrer()); |
| |
| if (range.peek().functionId() != CSSValueFormat) |
| return uriValue; |
| |
| // FIXME: https://drafts.csswg.org/css-fonts says that format() contains a |
| // comma-separated list of strings, but CSSFontFaceSrcValue stores only one |
| // format. Allowing one format for now. |
| CSSParserTokenRange args = consumeFunction(range); |
| const CSSParserToken& arg = args.consumeIncludingWhitespace(); |
| if ((arg.type() != StringToken) || !args.atEnd()) |
| return nullptr; |
| uriValue->setFormat(arg.value().toString()); |
| return uriValue; |
| } |
| |
| static CSSValue* consumeFontFaceSrcLocal(CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| CSSParserTokenRange args = consumeFunction(range); |
| ContentSecurityPolicyDisposition shouldCheckContentSecurityPolicy = |
| context.shouldCheckContentSecurityPolicy(); |
| if (args.peek().type() == StringToken) { |
| const CSSParserToken& arg = args.consumeIncludingWhitespace(); |
| if (!args.atEnd()) |
| return nullptr; |
| return CSSFontFaceSrcValue::createLocal(arg.value().toString(), |
| shouldCheckContentSecurityPolicy); |
| } |
| if (args.peek().type() == IdentToken) { |
| String familyName = concatenateFamilyName(args); |
| if (!args.atEnd()) |
| return nullptr; |
| return CSSFontFaceSrcValue::createLocal(familyName, |
| shouldCheckContentSecurityPolicy); |
| } |
| return nullptr; |
| } |
| |
| static CSSValueList* consumeFontFaceSrc(CSSParserTokenRange& range, |
| const CSSParserContext& context) { |
| CSSValueList* values = CSSValueList::createCommaSeparated(); |
| |
| do { |
| const CSSParserToken& token = range.peek(); |
| CSSValue* parsedValue = nullptr; |
| if (token.functionId() == CSSValueLocal) |
| parsedValue = consumeFontFaceSrcLocal(range, context); |
| else |
| parsedValue = consumeFontFaceSrcURI(range, context); |
| if (!parsedValue) |
| return nullptr; |
| values->append(*parsedValue); |
| } while (consumeCommaIncludingWhitespace(range)); |
| return values; |
| } |
| |
| bool CSSPropertyParser::parseFontFaceDescriptor(CSSPropertyID propId) { |
| CSSValue* parsedValue = nullptr; |
| switch (propId) { |
| case CSSPropertyFontFamily: |
| if (consumeGenericFamily(m_range)) |
| return false; |
| parsedValue = consumeFamilyName(m_range); |
| break; |
| case CSSPropertySrc: // This is a list of urls or local references. |
| parsedValue = consumeFontFaceSrc(m_range, m_context); |
| break; |
| case CSSPropertyUnicodeRange: |
| parsedValue = consumeFontFaceUnicodeRange(m_range); |
| break; |
| case CSSPropertyFontDisplay: |
| parsedValue = consumeFontDisplay(m_range); |
| break; |
| case CSSPropertyFontStretch: |
| case CSSPropertyFontStyle: { |
| CSSValueID id = m_range.consumeIncludingWhitespace().id(); |
| if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(propId, id, |
| m_context.mode())) |
| return false; |
| parsedValue = CSSIdentifierValue::create(id); |
| break; |
| } |
| case CSSPropertyFontVariant: |
| parsedValue = consumeFontVariantList(m_range); |
| break; |
| case CSSPropertyFontWeight: |
| parsedValue = consumeFontWeight(m_range); |
| break; |
| case CSSPropertyFontFeatureSettings: |
| parsedValue = consumeFontFeatureSettings(m_range); |
| break; |
| default: |
| break; |
| } |
| |
| if (!parsedValue || !m_range.atEnd()) |
| return false; |
| |
| addProperty(propId, CSSPropertyInvalid, *parsedValue, false); |
| return true; |
| } |
| |
| bool CSSPropertyParser::consumeSystemFont(bool important) { |
| CSSValueID systemFontID = m_range.consumeIncludingWhitespace().id(); |
| ASSERT(systemFontID >= CSSValueCaption && systemFontID <= CSSValueStatusBar); |
| if (!m_range.atEnd()) |
| return false; |
| |
| FontStyle fontStyle = FontStyleNormal; |
| FontWeight fontWeight = FontWeightNormal; |
| float fontSize = 0; |
| AtomicString fontFamily; |
| LayoutTheme::theme().systemFont(systemFontID, fontStyle, fontWeight, fontSize, |
| fontFamily); |
| |
| addProperty(CSSPropertyFontStyle, CSSPropertyFont, |
| *CSSIdentifierValue::create(fontStyle == FontStyleItalic |
| ? CSSValueItalic |
| : CSSValueNormal), |
| important); |
| addProperty(CSSPropertyFontWeight, CSSPropertyFont, |
| *CSSIdentifierValue::create(fontWeight), important); |
| addProperty( |
| CSSPropertyFontSize, CSSPropertyFont, |
| *CSSPrimitiveValue::create(fontSize, CSSPrimitiveValue::UnitType::Pixels), |
| important); |
| CSSValueList* fontFamilyList = CSSValueList::createCommaSeparated(); |
| fontFamilyList->append(*CSSFontFamilyValue::create(fontFamily)); |
| addProperty(CSSPropertyFontFamily, CSSPropertyFont, *fontFamilyList, |
| important); |
| |
| addProperty(CSSPropertyFontStretch, CSSPropertyFont, |
| *CSSIdentifierValue::create(CSSValueNormal), important); |
| addProperty(CSSPropertyFontVariantCaps, CSSPropertyFont, |
| *CSSIdentifierValue::create(CSSValueNormal), important); |
| addProperty(CSSPropertyFontVariantLigatures, CSSPropertyFont, |
| *CSSIdentifierValue::create(CSSValueNormal), important); |
| addProperty(CSSPropertyFontVariantNumeric, CSSPropertyFont, |
| *CSSIdentifierValue::create(CSSValueNormal), important); |
| addProperty(CSSPropertyLineHeight, CSSPropertyFont, |
| *CSSIdentifierValue::create(CSSValueNormal), important); |
| return true; |
| } |
| |
| bool CSSPropertyParser::consumeFont(bool important) { |
| // Let's check if there is an inherit or initial somewhere in the shorthand. |
| CSSParserTokenRange range = m_range; |
| while (!range.atEnd()) { |
| CSSValueID id = range.consumeIncludingWhitespace().id(); |
| if (id == CSSValueInherit || id == CSSValueInitial) |
| return false; |
| } |
| // Optional font-style, font-variant, font-stretch and font-weight. |
| CSSIdentifierValue* fontStyle = nullptr; |
| CSSIdentifierValue* fontVariantCaps = nullptr; |
| CSSIdentifierValue* fontWeight = nullptr; |
| CSSIdentifierValue* fontStretch = nullptr; |
| while (!m_range.atEnd()) { |
| CSSValueID id = m_range.peek().id(); |
| if (!fontStyle && CSSParserFastPaths::isValidKeywordPropertyAndValue( |
| CSSPropertyFontStyle, id, m_context.mode())) { |
| fontStyle = consumeIdent(m_range); |
| continue; |
| } |
| if (!fontVariantCaps && (id == CSSValueNormal || id == CSSValueSmallCaps)) { |
| // Font variant in the shorthand is particular, it only accepts normal or |
| // small-caps. |
| // See https://drafts.csswg.org/css-fonts/#propdef-font |
| fontVariantCaps = consumeFontVariantCSS21(m_range); |
| if (fontVariantCaps) |
| continue; |
| } |
| if (!fontWeight) { |
| fontWeight = consumeFontWeight(m_range); |
| if (fontWeight) |
| continue; |
| } |
| if (!fontStretch && CSSParserFastPaths::isValidKeywordPropertyAndValue( |
| CSSPropertyFontStretch, id, m_context.mode())) |
| fontStretch = consumeIdent(m_range); |
| else |
| break; |
| } |
| |
| if (m_range.atEnd()) |
| return false; |
| |
| addProperty( |
| CSSPropertyFontStyle, CSSPropertyFont, |
| fontStyle ? *fontStyle : *CSSIdentifierValue::create(CSSValueNormal), |
| important); |
| addProperty(CSSPropertyFontVariantCaps, CSSPropertyFont, |
| fontVariantCaps ? *fontVariantCaps |
| : *CSSIdentifierValue::create(CSSValueNormal), |
| important); |
| addProperty(CSSPropertyFontVariantLigatures, CSSPropertyFont, |
| *CSSIdentifierValue::create(CSSValueNormal), important); |
| addProperty(CSSPropertyFontVariantNumeric, CSSPropertyFont, |
| *CSSIdentifierValue::create(CSSValueNormal), important); |
| |
| addProperty( |
| CSSPropertyFontWeight, CSSPropertyFont, |
| fontWeight ? *fontWeight : *CSSIdentifierValue::create(CSSValueNormal), |
| important); |
| addProperty( |
| CSSPropertyFontStretch, CSSPropertyFont, |
| fontStretch ? *fontStretch : *CSSIdentifierValue::create(CSSValueNormal), |
| important); |
| |
| // Now a font size _must_ come. |
| CSSValue* fontSize = consumeFontSize(m_range, m_context.mode()); |
| if (!fontSize || m_range.atEnd()) |
| return false; |
| |
| addProperty(CSSPropertyFontSize, CSSPropertyFont, *fontSize, important); |
| |
| if (consumeSlashIncludingWhitespace(m_range)) { |
| CSSValue* lineHeight = consumeLineHeight(m_range, m_context.mode()); |
| if (!lineHeight) |
| return false; |
| addProperty(CSSPropertyLineHeight, CSSPropertyFont, *lineHeight, important); |
| } else { |
| addProperty(CSSPropertyLineHeight, CSSPropertyFont, |
| *CSSIdentifierValue::create(CSSValueNormal), important); |
| } |
| |
| // Font family must come now. |
| CSSValue* parsedFamilyValue = consumeFontFamily(m_range); |
| if (!parsedFamilyValue) |
| return false; |
| |
| addProperty(CSSPropertyFontFamily, CSSPropertyFont, *parsedFamilyValue, |
| important); |
| |
| // FIXME: http://www.w3.org/TR/2011/WD-css3-fonts-20110324/#font-prop requires |
| // that "font-stretch", "font-size-adjust", and "font-kerning" be reset to |
| // their initial values but we don't seem to support them at the moment. They |
| // should also be added here once implemented. |
| return m_range.atEnd(); |
| } |
| |
| bool CSSPropertyParser::consumeFontVariantShorthand(bool important) { |
| if (identMatches<CSSValueNormal, CSSValueNone>(m_range.peek().id())) { |
| addProperty(CSSPropertyFontVariantLigatures, CSSPropertyFontVariant, |
| *consumeIdent(m_range), important); |
| addProperty(CSSPropertyFontVariantCaps, CSSPropertyFontVariant, |
| *CSSIdentifierValue::create(CSSValueNormal), important); |
| return m_range.atEnd(); |
| } |
| |
| CSSIdentifierValue* capsValue = nullptr; |
| FontVariantLigaturesParser ligaturesParser; |
| FontVariantNumericParser numericParser; |
| do { |
| FontVariantLigaturesParser::ParseResult ligaturesParseResult = |
| ligaturesParser.consumeLigature(m_range); |
| FontVariantNumericParser::ParseResult numericParseResult = |
| numericParser.consumeNumeric(m_range); |
| if (ligaturesParseResult == |
| FontVariantLigaturesParser::ParseResult::ConsumedValue || |
| numericParseResult == |
| FontVariantNumericParser::ParseResult::ConsumedValue) |
| continue; |
| |
| if (ligaturesParseResult == |
| FontVariantLigaturesParser::ParseResult::DisallowedValue || |
| numericParseResult == |
| FontVariantNumericParser::ParseResult::DisallowedValue) |
| return false; |
| |
| CSSValueID id = m_range.peek().id(); |
| switch (id) { |
| case CSSValueSmallCaps: |
| case CSSValueAllSmallCaps: |
| case CSSValuePetiteCaps: |
| case CSSValueAllPetiteCaps: |
| case CSSValueUnicase: |
| case CSSValueTitlingCaps: |
| // Only one caps value permitted in font-variant grammar. |
| if (capsValue) |
| return false; |
| capsValue = consumeIdent(m_range); |
| break; |
| default: |
| return false; |
| } |
| } while (!m_range.atEnd()); |
| |
| addProperty(CSSPropertyFontVariantLigatures, CSSPropertyFontVariant, |
| *ligaturesParser.finalizeValue(), important); |
| addProperty(CSSPropertyFontVariantNumeric, CSSPropertyFontVariant, |
| *numericParser.finalizeValue(), important); |
| addProperty( |
| CSSPropertyFontVariantCaps, CSSPropertyFontVariant, |
| capsValue ? *capsValue : *CSSIdentifierValue::create(CSSValueNormal), |
| important); |
| return true; |
| } |
| |
| bool CSSPropertyParser::consumeBorderSpacing(bool important) { |
| CSSValue* horizontalSpacing = consumeLength( |
| m_range, m_context.mode(), ValueRangeNonNegative, UnitlessQuirk::Allow); |
| if (!horizontalSpacing) |
| return false; |
| CSSValue* verticalSpacing = horizontalSpacing; |
| if (!m_range.atEnd()) |
| verticalSpacing = consumeLength( |
| m_range, m_context.mode(), ValueRangeNonNegative, UnitlessQuirk::Allow); |
| if (!verticalSpacing || !m_range.atEnd()) |
| return false; |
| addProperty(CSSPropertyWebkitBorderHorizontalSpacing, |
| CSSPropertyBorderSpacing, *horizontalSpacing, important); |
| addProperty(CSSPropertyWebkitBorderVerticalSpacing, CSSPropertyBorderSpacing, |
| *verticalSpacing, important); |
| return true; |
| } |
| |
| static CSSValue* consumeSingleViewportDescriptor(CSSParserTokenRange& range, |
| CSSPropertyID propId, |
| CSSParserMode cssParserMode) { |
| CSSValueID id = range.peek().id(); |
| switch (propId) { |
| case CSSPropertyMinWidth: |
| case CSSPropertyMaxWidth: |
| case CSSPropertyMinHeight: |
| case CSSPropertyMaxHeight: |
| if (id == CSSValueAuto || id == CSSValueInternalExtendToZoom) |
| return consumeIdent(range); |
| return consumeLengthOrPercent(range, cssParserMode, |
| ValueRangeNonNegative); |
| case CSSPropertyMinZoom: |
| case CSSPropertyMaxZoom: |
| case CSSPropertyZoom: { |
| if (id == CSSValueAuto) |
| return consumeIdent(range); |
| CSSValue* parsedValue = consumeNumber(range, ValueRangeNonNegative); |
| if (parsedValue) |
| return parsedValue; |
| return consumePercent(range, ValueRangeNonNegative); |
| } |
| case CSSPropertyUserZoom: |
| return consumeIdent<CSSValueZoom, CSSValueFixed>(range); |
| case CSSPropertyOrientation: |
| return consumeIdent<CSSValueAuto, CSSValuePortrait, CSSValueLandscape>( |
| range); |
| default: |
| ASSERT_NOT_REACHED(); |
| break; |
| } |
| |
| ASSERT_NOT_REACHED(); |
| return nullptr; |
| } |
| |
| bool CSSPropertyParser::parseViewportDescriptor(CSSPropertyID propId, |
| bool important) { |
| ASSERT(RuntimeEnabledFeatures::cssViewportEnabled() || |
| isUASheetBehavior(m_context.mode())); |
| |
| switch (propId) { |
| case CSSPropertyWidth: { |
| CSSValue* minWidth = consumeSingleViewportDescriptor( |
| m_range, CSSPropertyMinWidth, m_context.mode()); |
| if (!minWidth) |
| return false; |
| CSSValue* maxWidth = minWidth; |
| if (!m_range.atEnd()) |
| maxWidth = consumeSingleViewportDescriptor(m_range, CSSPropertyMaxWidth, |
| m_context.mode()); |
| if (!maxWidth || !m_range.atEnd()) |
| return false; |
| addProperty(CSSPropertyMinWidth, CSSPropertyInvalid, *minWidth, |
| important); |
| addProperty(CSSPropertyMaxWidth, CSSPropertyInvalid, *maxWidth, |
| important); |
| return true; |
| } |
| case CSSPropertyHeight: { |
| CSSValue* minHeight = consumeSingleViewportDescriptor( |
| m_range, CSSPropertyMinHeight, m_context.mode()); |
| if (!minHeight) |
| return false; |
| CSSValue* maxHeight = minHeight; |
| if (!m_range.atEnd()) |
| maxHeight = consumeSingleViewportDescriptor( |
| m_range, CSSPropertyMaxHeight, m_context.mode()); |
| if (!maxHeight || !m_range.atEnd()) |
| return false; |
| addProperty(CSSPropertyMinHeight, CSSPropertyInvalid, *minHeight, |
| important); |
| addProperty(CSSPropertyMaxHeight, CSSPropertyInvalid, *maxHeight, |
| important); |
| return true; |
| } |
| case CSSPropertyMinWidth: |
| case CSSPropertyMaxWidth: |
| case CSSPropertyMinHeight: |
| case CSSPropertyMaxHeight: |
| case CSSPropertyMinZoom: |
| case CSSPropertyMaxZoom: |
| case CSSPropertyZoom: |
| case CSSPropertyUserZoom: |
| case CSSPropertyOrientation: { |
| CSSValue* parsedValue = |
| consumeSingleViewportDescriptor(m_range, propId, m_context.mode()); |
| if (!parsedValue || !m_range.atEnd()) |
| return false; |
| addProperty(propId, CSSPropertyInvalid, *parsedValue, important); |
| return true; |
| } |
| default: |
| return false; |
| } |
| } |
| |
| static bool consumeColumnWidthOrCount(CSSParserTokenRange& range, |
| CSSValue*& columnWidth, |
| CSSValue*& columnCount) { |
| if (range.peek().id() == CSSValueAuto) { |
| consumeIdent(range); |
| return true; |
| } |
| if (!columnWidth) { |
| columnWidth = consumeColumnWidth(range); |
| if (columnWidth) |
| return true; |
| } |
| if (!columnCount) |
| columnCount = consumeColumnCount(range); |
| return columnCount; |
| } |
| |
| bool CSSPropertyParser::consumeColumns(bool important) { |
| CSSValue* columnWidth = nullptr; |
| CSSValue* columnCount = nullptr; |
| if (!consumeColumnWidthOrCount(m_range, columnWidth, columnCount)) |
| return false; |
| consumeColumnWidthOrCount(m_range, columnWidth, columnCount); |
| if (!m_range.atEnd()) |
| return false; |
| if (!columnWidth) |
| columnWidth = CSSIdentifierValue::create(CSSValueAuto); |
| if (!columnCount) |
| columnCount = CSSIdentifierValue::create(CSSValueAuto); |
| addProperty(CSSPropertyColumnWidth, CSSPropertyInvalid, *columnWidth, |
| important); |
| addProperty(CSSPropertyColumnCount, CSSPropertyInvalid, *columnCount, |
| important); |
| return true; |
| } |
| |
| bool CSSPropertyParser::consumeShorthandGreedily( |
| const StylePropertyShorthand& shorthand, |
| bool important) { |
| ASSERT(shorthand.length() <= |
| 6); // Existing shorthands have at most 6 longhands. |
| const CSSValue* longhands[6] = {nullptr, nullptr, nullptr, |
| nullptr, nullptr, nullptr}; |
| const CSSPropertyID* shorthandProperties = shorthand.properties(); |
| do { |
| bool foundLonghand = false; |
| for (size_t i = 0; !foundLonghand && i < shorthand.length(); ++i) { |
| if (longhands[i]) |
| continue; |
| longhands[i] = parseSingleValue(shorthandProperties[i], shorthand.id()); |
| if (longhands[i]) |
| foundLonghand = true; |
| } |
| if (!foundLonghand) |
| return false; |
| } while (!m_range.atEnd()); |
| |
| for (size_t i = 0; i < shorthand.length(); ++i) { |
| if (longhands[i]) |
| addProperty(shorthandProperties[i], shorthand.id(), *longhands[i], |
| important); |
| else |
| addProperty(shorthandProperties[i], shorthand.id(), |
| *CSSInitialValue::createLegacyImplicit(), important); |
| } |
| return true; |
| } |
| |
| bool CSSPropertyParser::consumeFlex(bool important) { |
| static const double unsetValue = -1; |
| double flexGrow = unsetValue; |
| double flexShrink = unsetValue; |
| CSSValue* flexBasis = nullptr; |
| |
| if (m_range.peek().id() == CSSValueNone) { |
| flexGrow = 0; |
| flexShrink = 0; |
| flexBasis = CSSIdentifierValue::create(CSSValueAuto); |
| m_range.consumeIncludingWhitespace(); |
| } else { |
| unsigned index = 0; |
| while (!m_range.atEnd() && index++ < 3) { |
| double num; |
| if (consumeNumberRaw(m_range, num)) { |
| if (num < 0) |
| return false; |
| if (flexGrow == unsetValue) |
| 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. |
| flexBasis = |
| CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::Pixels); |
| else |
| return false; |
| } else if (!flexBasis) { |
| if (m_range.peek().id() == CSSValueAuto) |
| flexBasis = consumeIdent(m_range); |
| if (!flexBasis) |
| flexBasis = consumeLengthOrPercent(m_range, m_context.mode(), |
| ValueRangeNonNegative); |
| if (index == 2 && !m_range.atEnd()) |
| return false; |
| } |
| } |
| if (index == 0) |
| return false; |
| if (flexGrow == unsetValue) |
| flexGrow = 1; |
| if (flexShrink == unsetValue) |
| flexShrink = 1; |
| if (!flexBasis) |
| flexBasis = |
| CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::Percentage); |
| } |
| |
| if (!m_range.atEnd()) |
| return false; |
| addProperty(CSSPropertyFlexGrow, CSSPropertyFlex, |
| *CSSPrimitiveValue::create(clampTo<float>(flexGrow), |
| CSSPrimitiveValue::UnitType::Number), |
| important); |
| addProperty(CSSPropertyFlexShrink, CSSPropertyFlex, |
| *CSSPrimitiveValue::create(clampTo<float>(flexShrink), |
| CSSPrimitiveValue::UnitType::Number), |
| important); |
| addProperty(CSSPropertyFlexBasis, CSSPropertyFlex, *flexBasis, important); |
| return true; |
| } |
| |
| bool CSSPropertyParser::consumeBorder(bool important) { |
| CSSValue* width = nullptr; |
| const CSSValue* style = nullptr; |
| CSSValue* color = nullptr; |
| |
| while (!width || !style || !color) { |
| if (!width) { |
| width = |
| consumeLineWidth(m_range, m_context.mode(), UnitlessQuirk::Forbid); |
| if (width) |
| continue; |
| } |
| if (!style) { |
| style = parseSingleValue(CSSPropertyBorderLeftStyle, CSSPropertyBorder); |
| if (style) |
| continue; |
| } |
| if (!color) { |
| color = consumeColor(m_range, m_context.mode()); |
| if (color) |
| continue; |
| } |
| break; |
| } |
| |
| if (!width && !style && !color) |
| return false; |
| |
| if (!width) |
| width = CSSInitialValue::createLegacyImplicit(); |
| if (!style) |
| style = CSSInitialValue::createLegacyImplicit(); |
| if (!color) |
| color = CSSInitialValue::createLegacyImplicit(); |
| |
| addExpandedPropertyForValue(CSSPropertyBorderWidth, *width, important); |
| addExpandedPropertyForValue(CSSPropertyBorderStyle, *style, important); |
| addExpandedPropertyForValue(CSSPropertyBorderColor, *color, important); |
| addExpandedPropertyForValue(CSSPropertyBorderImage, |
| *CSSInitialValue::createLegacyImplicit(), |
| important); |
| |
| return m_range.atEnd(); |
| } |
| |
| bool CSSPropertyParser::consume4Values(const StylePropertyShorthand& shorthand, |
| bool important) { |
| ASSERT(shorthand.length() == 4); |
| const CSSPropertyID* longhands = shorthand.properties(); |
| const CSSValue* top = parseSingleValue(longhands[0], shorthand.id()); |
| if (!top) |
| return false; |
| |
| const CSSValue* right = parseSingleValue(longhands[1], shorthand.id()); |
| const CSSValue* bottom = nullptr; |
| const CSSValue* left = nullptr; |
| if (right) { |
| bottom = parseSingleValue(longhands[2], shorthand.id()); |
| if (bottom) |
| left = parseSingleValue(longhands[3], shorthand.id()); |
| } |
| |
| if (!right) |
| right = top; |
| if (!bottom) |
| bottom = top; |
| if (!left) |
| left = right; |
| |
| addProperty(longhands[0], shorthand.id(), *top, important); |
| addProperty(longhands[1], shorthand.id(), *right, important); |
| addProperty(longhands[2], shorthand.id(), *bottom, important); |
| addProperty(longhands[3], shorthand.id(), *left, important); |
| |
| return m_range.atEnd(); |
| } |
| |
| bool CSSPropertyParser::consumeBorderImage(CSSPropertyID property, |
| bool important) { |
| CSSValue* source = nullptr; |
| CSSValue* slice = nullptr; |
| CSSValue* width = nullptr; |
| CSSValue* outset = nullptr; |
| CSSValue* repeat = nullptr; |
| if (consumeBorderImageComponents(property, m_range, m_context, source, slice, |
| width, outset, repeat)) { |
| switch (property) { |
| case CSSPropertyWebkitMaskBoxImage: |
| addProperty(CSSPropertyWebkitMaskBoxImageSource, |
| CSSPropertyWebkitMaskBoxImage, |
| source ? *source : *CSSInitialValue::createLegacyImplicit(), |
| important); |
| addProperty(CSSPropertyWebkitMaskBoxImageSlice, |
| CSSPropertyWebkitMaskBoxImage, |
| slice ? *slice : *CSSInitialValue::createLegacyImplicit(), |
| important); |
| addProperty(CSSPropertyWebkitMaskBoxImageWidth, |
| CSSPropertyWebkitMaskBoxImage, |
| width ? *width : *CSSInitialValue::createLegacyImplicit(), |
| important); |
| addProperty(CSSPropertyWebkitMaskBoxImageOutset, |
| CSSPropertyWebkitMaskBoxImage, |
| outset ? *outset : *CSSInitialValue::createLegacyImplicit(), |
| important); |
| addProperty(CSSPropertyWebkitMaskBoxImageRepeat, |
| CSSPropertyWebkitMaskBoxImage, |
| repeat ? *repeat : *CSSInitialValue::createLegacyImplicit(), |
| important); |
| return true; |
| case CSSPropertyBorderImage: |
| addProperty(CSSPropertyBorderImageSource, CSSPropertyBorderImage, |
| source ? *source : *CSSInitialValue::createLegacyImplicit(), |
| important); |
| addProperty(CSSPropertyBorderImageSlice, CSSPropertyBorderImage, |
| slice ? *slice : *CSSInitialValue::createLegacyImplicit(), |
| important); |
| addProperty(CSSPropertyBorderImageWidth, CSSPropertyBorderImage, |
| width ? *width : *CSSInitialValue::createLegacyImplicit(), |
| important); |
| addProperty(CSSPropertyBorderImageOutset, CSSPropertyBorderImage, |
| outset ? *outset : *CSSInitialValue::createLegacyImplicit(), |
| important); |
| addProperty(CSSPropertyBorderImageRepeat, CSSPropertyBorderImage, |
| repeat ? *repeat : *CSSInitialValue::createLegacyImplicit(), |
| important); |
| return true; |
| default: |
| ASSERT_NOT_REACHED(); |
| return false; |
| } |
| } |
| return false; |
| } |
| |
| static inline CSSValueID mapFromPageBreakBetween(CSSValueID value) { |
| if (value == CSSValueAlways) |
| return CSSValuePage; |
| if (value == CSSValueAuto || value == CSSValueAvoid || |
| value == CSSValueLeft || value == CSSValueRight) |
| return value; |
| return CSSValueInvalid; |
| } |
| |
| static inline CSSValueID mapFromColumnBreakBetween(CSSValueID value) { |
| if (value == CSSValueAlways) |
| return CSSValueColumn; |
| if (value == CSSValueAuto || value == CSSValueAvoid) |
| return value; |
| return CSSValueInvalid; |
| } |
| |
| static inline CSSValueID mapFromColumnOrPageBreakInside(CSSValueID value) { |
| if (value == CSSValueAuto || value == CSSValueAvoid) |
| return value; |
| return CSSValueInvalid; |
| } |
| |
| static inline CSSPropertyID mapFromLegacyBreakProperty(CSSPropertyID property) { |
| if (property == CSSPropertyPageBreakAfter || |
| property == CSSPropertyWebkitColumnBreakAfter) |
| return CSSPropertyBreakAfter; |
| if (property == CSSPropertyPageBreakBefore || |
| property == CSSPropertyWebkitColumnBreakBefore) |
| return CSSPropertyBreakBefore; |
| ASSERT(property == CSSPropertyPageBreakInside || |
| property == CSSPropertyWebkitColumnBreakInside); |
| return CSSPropertyBreakInside; |
| } |
| |
| bool CSSPropertyParser::consumeLegacyBreakProperty(CSSPropertyID property, |
| bool important) { |
| // The fragmentation spec says that page-break-(after|before|inside) are to be |
| // treated as shorthands for their break-(after|before|inside) counterparts. |
| // We'll do the same for the non-standard properties |
| // -webkit-column-break-(after|before|inside). |
| CSSIdentifierValue* keyword = consumeIdent(m_range); |
| if (!keyword) |
| return false; |
| if (!m_range.atEnd()) |
| return false; |
| CSSValueID value = keyword->getValueID(); |
| switch (property) { |
| case CSSPropertyPageBreakAfter: |
| case CSSPropertyPageBreakBefore: |
| value = mapFromPageBreakBetween(value); |
| break; |
| case CSSPropertyWebkitColumnBreakAfter: |
| case CSSPropertyWebkitColumnBreakBefore: |
| value = mapFromColumnBreakBetween(value); |
| break; |
| case CSSPropertyPageBreakInside: |
| case CSSPropertyWebkitColumnBreakInside: |
| value = mapFromColumnOrPageBreakInside(value); |
| break; |
| default: |
| ASSERT_NOT_REACHED(); |
| } |
| if (value == CSSValueInvalid) |
| return false; |
| |
| CSSPropertyID genericBreakProperty = mapFromLegacyBreakProperty(property); |
| addProperty(genericBreakProperty, property, |
| *CSSIdentifierValue::create(value), important); |
| return true; |
| } |
| |
| static bool consumeBackgroundPosition(CSSParserTokenRange& range, |
| const CSSParserContext& context, |
| UnitlessQuirk unitless, |
| CSSValue*& resultX, |
| CSSValue*& resultY) { |
| do { |
| CSSValue* positionX = nullptr; |
| CSSValue* positionY = nullptr; |
| if (!consumePosition(range, context.mode(), unitless, positionX, positionY)) |
| return false; |
| addBackgroundValue(resultX, positionX); |
| addBackgroundValue(resultY, positionY); |
| } while (consumeCommaIncludingWhitespace(range)); |
| return true; |
| } |
| |
| static bool consumeRepeatStyleComponent(CSSParserTokenRange& range, |
| CSSValue*& value1, |
| CSSValue*& value2, |
| bool& implicit) { |
| if (consumeIdent<CSSValueRepeatX>(range)) { |
| value1 = CSSIdentifierValue::create(CSSValueRepeat); |
| value2 = CSSIdentifierValue::create(CSSValueNoRepeat); |
| implicit = true; |
| return true; |
| } |
| if (consumeIdent<CSSValueRepeatY>(range)) { |
| value1 = CSSIdentifierValue::create(CSSValueNoRepeat); |
| value2 = CSSIdentifierValue::create(CSSValueRepeat); |
| implicit = true; |
| return true; |
| } |
| value1 = consumeIdent<CSSValueRepeat, CSSValueNoRepeat, CSSValueRound, |
| CSSValueSpace>(range); |
| if (!value1) |
| return false; |
| |
| value2 = consumeIdent<CSSValueRepeat, CSSValueNoRepeat, CSSValueRound, |
| CSSValueSpace>(range); |
| if (!value2) { |
| value2 = value1; |
| implicit = true; |
| } |
| return true; |
| } |
| |
| static bool consumeRepeatStyle(CSSParserTokenRange& range, |
| CSSValue*& resultX, |
| CSSValue*& resultY, |
| bool& implicit) { |
| do { |
| CSSValue* repeatX = nullptr; |
| CSSValue* repeatY = nullptr; |
| if (!consumeRepeatStyleComponent(range, repeatX, repeatY, implicit)) |
| return false; |
| addBackgroundValue(resultX, repeatX); |
| addBackgroundValue(resultY, repeatY); |
| } while (consumeCommaIncludingWhitespace(range)); |
| return true; |
| } |
| |
| // Note: consumeBackgroundShorthand assumes y properties (for example |
| // background-position-y) follow the x properties in the shorthand array. |
| bool CSSPropertyParser::consumeBackgroundShorthand( |
| const StylePropertyShorthand& shorthand, |
| bool important) { |
| const unsigned longhandCount = shorthand.length(); |
| CSSValue* longhands[10] = {0}; |
| ASSERT(longhandCount <= 10); |
| |
| bool implicit = false; |
| do { |
| bool parsedLonghand[10] = {false}; |
| CSSValue* originValue = nullptr; |
| do { |
| bool foundProperty = false; |
| for (size_t i = 0; i < longhandCount; ++i) { |
| if (parsedLonghand[i]) |
| continue; |
| |
| CSSValue* value = nullptr; |
| CSSValue* valueY = nullptr; |
| CSSPropertyID property = shorthand.properties()[i]; |
| if (property == CSSPropertyBackgroundRepeatX || |
| property == CSSPropertyWebkitMaskRepeatX) { |
| consumeRepeatStyleComponent(m_range, value, valueY, implicit); |
| } else if (property == CSSPropertyBackgroundPositionX || |
| property == CSSPropertyWebkitMaskPositionX) { |
| if (!consumePosition(m_range, m_context.mode(), UnitlessQuirk::Forbid, |
| value, valueY)) |
| continue; |
| } else if (property == CSSPropertyBackgroundSize || |
| property == CSSPropertyWebkitMaskSize) { |
| if (!consumeSlashIncludingWhitespace(m_range)) |
| continue; |
| value = consumeBackgroundSize(property, m_range, m_context.mode()); |
| if (!value || !parsedLonghand[i - 1]) // Position must have been |
| // parsed in the current layer. |
| return false; |
| } else if (property == CSSPropertyBackgroundPositionY || |
| property == CSSPropertyBackgroundRepeatY || |
| property == CSSPropertyWebkitMaskPositionY || |
| property == CSSPropertyWebkitMaskRepeatY) { |
| continue; |
| } else { |
| value = consumeBackgroundComponent(property, m_range, m_context); |
| } |
| if (value) { |
| if (property == CSSPropertyBackgroundOrigin || |
| property == CSSPropertyWebkitMaskOrigin) |
| originValue = value; |
| parsedLonghand[i] = true; |
| foundProperty = true; |
| addBackgroundValue(longhands[i], value); |
| if (valueY) { |
| parsedLonghand[i + 1] = true; |
| addBackgroundValue(longhands[i + 1], valueY); |
| } |
| } |
| } |
| if (!foundProperty) |
| return false; |
| } while (!m_range.atEnd() && m_range.peek().type() != CommaToken); |
| |
| // TODO(timloh): This will make invalid longhands, see crbug.com/386459 |
| for (size_t i = 0; i < longhandCount; ++i) { |
| CSSPropertyID property = shorthand.properties()[i]; |
| if (property == CSSPropertyBackgroundColor && !m_range.atEnd()) { |
| if (parsedLonghand[i]) |
| return false; // Colors are only allowed in the last layer. |
| continue; |
| } |
| if ((property == CSSPropertyBackgroundClip || |
| property == CSSPropertyWebkitMaskClip) && |
| !parsedLonghand[i] && originValue) { |
| addBackgroundValue(longhands[i], originValue); |
| continue; |
| } |
| if (!parsedLonghand[i]) |
| addBackgroundValue(longhands[i], |
| CSSInitialValue::createLegacyImplicit()); |
| } |
| } while (consumeCommaIncludingWhitespace(m_range)); |
| if (!m_range.atEnd()) |
| return false; |
| |
| for (size_t i = 0; i < longhandCount; ++i) { |
| CSSPropertyID property = shorthand.properties()[i]; |
| if (property == CSSPropertyBackgroundSize && longhands[i] && |
| m_context.useLegacyBackgroundSizeShorthandBehavior()) |
| continue; |
| addProperty(property, shorthand.id(), *longhands[i], important, implicit); |
| } |
| return true; |
| } |
| |
| bool CSSPropertyParser::consumeGridItemPositionShorthand( |
| CSSPropertyID shorthandId, |
| bool important) { |
| ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled()); |
| const StylePropertyShorthand& shorthand = shorthandForProperty(shorthandId); |
| ASSERT(shorthand.length() == 2); |
| CSSValue* startValue = consumeGridLine(m_range); |
| if (!startValue) |
| return false; |
| |
| CSSValue* endValue = nullptr; |
| if (consumeSlashIncludingWhitespace(m_range)) { |
| endValue = consumeGridLine(m_range); |
| if (!endValue) |
| return false; |
| } else { |
| endValue = startValue->isCustomIdentValue() |
| ? startValue |
| : CSSIdentifierValue::create(CSSValueAuto); |
| } |
| if (!m_range.atEnd()) |
| return false; |
| addProperty(shorthand.properties()[0], shorthandId, *startValue, important); |
| addProperty(shorthand.properties()[1], shorthandId, *endValue, important); |
| return true; |
| } |
| |
| bool CSSPropertyParser::consumeGridAreaShorthand(bool important) { |
| ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled()); |
| ASSERT(gridAreaShorthand().length() == 4); |
| CSSValue* rowStartValue = consumeGridLine(m_range); |
| if (!rowStartValue) |
| return false; |
| CSSValue* columnStartValue = nullptr; |
| CSSValue* rowEndValue = nullptr; |
| CSSValue* columnEndValue = nullptr; |
| if (consumeSlashIncludingWhitespace(m_range)) { |
| columnStartValue = consumeGridLine(m_range); |
| if (!columnStartValue) |
| return false; |
| if (consumeSlashIncludingWhitespace(m_range)) { |
| rowEndValue = consumeGridLine(m_range); |
| if (!rowEndValue) |
| return false; |
| if (consumeSlashIncludingWhitespace(m_range)) { |
| columnEndValue = consumeGridLine(m_range); |
| if (!columnEndValue) |
| return false; |
| } |
| } |
| } |
| if (!m_range.atEnd()) |
| return false; |
| if (!columnStartValue) { |
| columnStartValue = rowStartValue->isCustomIdentValue() |
| ? rowStartValue |
| : CSSIdentifierValue::create(CSSValueAuto); |
| } |
| if (!rowEndValue) { |
| rowEndValue = rowStartValue->isCustomIdentValue() |
| ? rowStartValue |
| : CSSIdentifierValue::create(CSSValueAuto); |
| } |
| if (!columnEndValue) { |
| columnEndValue = columnStartValue->isCustomIdentValue() |
| ? columnStartValue |
| : CSSIdentifierValue::create(CSSValueAuto); |
| } |
| |
| addProperty(CSSPropertyGridRowStart, CSSPropertyGridArea, *rowStartValue, |
| important); |
| addProperty(CSSPropertyGridColumnStart, CSSPropertyGridArea, |
| *columnStartValue, important); |
| addProperty(CSSPropertyGridRowEnd, CSSPropertyGridArea, *rowEndValue, |
| important); |
| addProperty(CSSPropertyGridColumnEnd, CSSPropertyGridArea, *columnEndValue, |
| important); |
| return true; |
| } |
| |
| bool CSSPropertyParser::consumeGridTemplateRowsAndAreasAndColumns( |
| CSSPropertyID shorthandId, |
| bool important) { |
| NamedGridAreaMap gridAreaMap; |
| size_t rowCount = 0; |
| size_t columnCount = 0; |
| CSSValueList* templateRows = CSSValueList::createSpaceSeparated(); |
| |
| // Persists between loop iterations so we can use the same value for |
| // consecutive <line-names> values |
| CSSGridLineNamesValue* lineNames = nullptr; |
| |
| do { |
| // Handle leading <custom-ident>*. |
| bool hasPreviousLineNames = lineNames; |
| lineNames = consumeGridLineNames(m_range, lineNames); |
| if (lineNames && !hasPreviousLineNames) |
| templateRows->append(*lineNames); |
| |
| // Handle a template-area's row. |
| if (m_range.peek().type() != StringToken || |
| !parseGridTemplateAreasRow( |
| m_range.consumeIncludingWhitespace().value().toString(), |
| gridAreaMap, rowCount, columnCount)) |
| return false; |
| ++rowCount; |
| |
| // Handle template-rows's track-size. |
| CSSValue* value = consumeGridTrackSize(m_range, m_context.mode()); |
| if (!value) |
| value = CSSIdentifierValue::create(CSSValueAuto); |
| templateRows->append(*value); |
| |
| // This will handle the trailing/leading <custom-ident>* in the grammar. |
| lineNames = consumeGridLineNames(m_range); |
| if (lineNames) |
| templateRows->append(*lineNames); |
| } while (!m_range.atEnd() && |
| !(m_range.peek().type() == DelimiterToken && |
| m_range.peek().delimiter() == '/')); |
| |
| CSSValue* columnsValue = nullptr; |
| if (!m_range.atEnd()) { |
| if (!consumeSlashIncludingWhitespace(m_range)) |
| return false; |
| columnsValue = |
| consumeGridTrackList(m_range, m_context.mode(), GridTemplateNoRepeat); |
| if (!columnsValue || !m_range.atEnd()) |
| return false; |
| } else { |
| columnsValue = CSSIdentifierValue::create(CSSValueNone); |
| } |
| addProperty(CSSPropertyGridTemplateRows, shorthandId, *templateRows, |
| important); |
| addProperty(CSSPropertyGridTemplateColumns, shorthandId, *columnsValue, |
| important); |
| addProperty( |
| CSSPropertyGridTemplateAreas, shorthandId, |
| *CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount), |
| important); |
| return true; |
| } |
| |
| bool CSSPropertyParser::consumeGridTemplateShorthand(CSSPropertyID shorthandId, |
| bool important) { |
| ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled()); |
| ASSERT(gridTemplateShorthand().length() == 3); |
| |
| CSSParserTokenRange rangeCopy = m_range; |
| CSSValue* rowsValue = consumeIdent<CSSValueNone>(m_range); |
| |
| // 1- 'none' case. |
| if (rowsValue && m_range.atEnd()) { |
| addProperty(CSSPropertyGridTemplateRows, shorthandId, |
| *CSSIdentifierValue::create(CSSValueNone), important); |
| addProperty(CSSPropertyGridTemplateColumns, shorthandId, |
| *CSSIdentifierValue::create(CSSValueNone), important); |
| addProperty(CSSPropertyGridTemplateAreas, shorthandId, |
| *CSSIdentifierValue::create(CSSValueNone), important); |
| return true; |
| } |
| |
| // 2- <grid-template-rows> / <grid-template-columns> |
| if (!rowsValue) |
| rowsValue = consumeGridTrackList(m_range, m_context.mode(), GridTemplate); |
| |
| if (rowsValue) { |
| if (!consumeSlashIncludingWhitespace(m_range)) |
| return false; |
| CSSValue* columnsValue = |
| consumeGridTemplatesRowsOrColumns(m_range, m_context.mode()); |
| if (!columnsValue || !m_range.atEnd()) |
| return false; |
| |
| addProperty(CSSPropertyGridTemplateRows, shorthandId, *rowsValue, |
| important); |
| addProperty(CSSPropertyGridTemplateColumns, shorthandId, *columnsValue, |
| important); |
| addProperty(CSSPropertyGridTemplateAreas, shorthandId, |
| *CSSIdentifierValue::create(CSSValueNone), important); |
| return true; |
| } |
| |
| // 3- [ <line-names>? <string> <track-size>? <line-names>? ]+ |
| // [ / <track-list> ]? |
| m_range = rangeCopy; |
| return consumeGridTemplateRowsAndAreasAndColumns(shorthandId, important); |
| } |
| |
| static CSSValueList* consumeImplicitAutoFlow(CSSParserTokenRange& range, |
| const CSSValue& flowDirection) { |
| // [ auto-flow && dense? ] |
| CSSValue* denseAlgorithm = nullptr; |
| if ((consumeIdent<CSSValueAutoFlow>(range))) { |
| denseAlgorithm = consumeIdent<CSSValueDense>(range); |
| } else { |
| denseAlgorithm = consumeIdent<CSSValueDense>(range); |
| if (!denseAlgorithm) |
| return nullptr; |
| if (!consumeIdent<CSSValueAutoFlow>(range)) |
| return nullptr; |
| } |
| CSSValueList* list = CSSValueList::createSpaceSeparated(); |
| list->append(flowDirection); |
| if (denseAlgorithm) |
| list->append(*denseAlgorithm); |
| return list; |
| } |
| |
| bool CSSPropertyParser::consumeGridShorthand(bool important) { |
| ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled()); |
| ASSERT(shorthandForProperty(CSSPropertyGrid).length() == 8); |
| |
| CSSParserTokenRange rangeCopy = m_range; |
| |
| // 1- <grid-template> |
| if (consumeGridTemplateShorthand(CSSPropertyGrid, important)) { |
| // It can only be specified the explicit or the implicit grid properties in |
| // a single grid declaration. The sub-properties not specified are set to |
| // their initial value, as normal for shorthands. |
| addProperty(CSSPropertyGridAutoFlow, CSSPropertyGrid, |
| *CSSInitialValue::createLegacyImplicit(), important); |
| addProperty(CSSPropertyGridAutoColumns, CSSPropertyGrid, |
| *CSSInitialValue::createLegacyImplicit(), important); |
| addProperty(CSSPropertyGridAutoRows, CSSPropertyGrid, |
| *CSSInitialValue::createLegacyImplicit(), important); |
| addProperty(CSSPropertyGridColumnGap, CSSPropertyGrid, |
| *CSSInitialValue::createLegacyImplicit(), important); |
| addProperty(CSSPropertyGridRowGap, CSSPropertyGrid, |
| *CSSInitialValue::createLegacyImplicit(), important); |
| return true; |
| } |
| |
| m_range = rangeCopy; |
| |
| CSSValue* autoColumnsValue = nullptr; |
| CSSValue* autoRowsValue = nullptr; |
| CSSValue* templateRows = nullptr; |
| CSSValue* templateColumns = nullptr; |
| CSSValueList* gridAutoFlow = nullptr; |
| if (identMatches<CSSValueDense, CSSValueAutoFlow>(m_range.peek().id())) { |
| // 2- [ auto-flow && dense? ] <grid-auto-rows>? / <grid-template-columns> |
| gridAutoFlow = consumeImplicitAutoFlow( |
| m_range, *CSSIdentifierValue::create(CSSValueRow)); |
| if (!gridAutoFlow) |
| return false; |
| if (consumeSlashIncludingWhitespace(m_range)) { |
| autoRowsValue = CSSInitialValue::createLegacyImplicit(); |
| } else { |
| autoRowsValue = consumeGridTrackList(m_range, m_context.mode(), GridAuto); |
| if (!autoRowsValue) |
| return false; |
| if (!consumeSlashIncludingWhitespace(m_range)) |
| return false; |
| } |
| if (!(templateColumns = |
| consumeGridTemplatesRowsOrColumns(m_range, m_context.mode()))) |
| return false; |
| templateRows = CSSInitialValue::createLegacyImplicit(); |
| autoColumnsValue = CSSInitialValue::createLegacyImplicit(); |
| } else { |
| // 3- <grid-template-rows> / [ auto-flow && dense? ] <grid-auto-columns>? |
| templateRows = consumeGridTemplatesRowsOrColumns(m_range, m_context.mode()); |
| if (!templateRows) |
| return false; |
| if (!consumeSlashIncludingWhitespace(m_range)) |
| return false; |
| gridAutoFlow = consumeImplicitAutoFlow( |
| m_range, *CSSIdentifierValue::create(CSSValueColumn)); |
| if (!gridAutoFlow) |
| return false; |
| if (m_range.atEnd()) { |
| autoColumnsValue = CSSInitialValue::createLegacyImplicit(); |
| } else { |
| autoColumnsValue = |
| consumeGridTrackList(m_range, m_context.mode(), GridAuto); |
| if (!autoColumnsValue) |
| return false; |
| } |
| templateColumns = CSSInitialValue::createLegacyImplicit(); |
| autoRowsValue = CSSInitialValue::createLegacyImplicit(); |
| } |
| |
| if (!m_range.atEnd()) |
| return false; |
| |
| // It can only be specified the explicit or the implicit grid properties in a |
| // single grid declaration. The sub-properties not specified are set to their |
| // initial value, as normal for shorthands. |
| addProperty(CSSPropertyGridTemplateColumns, CSSPropertyGrid, *templateColumns, |
| important); |
| addProperty(CSSPropertyGridTemplateRows, CSSPropertyGrid, *templateRows, |
| important); |
| addProperty(CSSPropertyGridTemplateAreas, CSSPropertyGrid, |
| *CSSInitialValue::createLegacyImplicit(), important); |
| addProperty(CSSPropertyGridAutoFlow, CSSPropertyGrid, *gridAutoFlow, |
| important); |
| addProperty(CSSPropertyGridAutoColumns, CSSPropertyGrid, *autoColumnsValue, |
| important); |
| addProperty(CSSPropertyGridAutoRows, CSSPropertyGrid, *autoRowsValue, |
| important); |
| addProperty(CSSPropertyGridColumnGap, CSSPropertyGrid, |
| *CSSInitialValue::createLegacyImplicit(), important); |
| addProperty(CSSPropertyGridRowGap, CSSPropertyGrid, |
| *CSSInitialValue::createLegacyImplicit(), important); |
| return true; |
| } |
| |
| bool CSSPropertyParser::parseShorthand(CSSPropertyID unresolvedProperty, |
| bool important) { |
| CSSPropertyID property = resolveCSSPropertyID(unresolvedProperty); |
| |
| switch (property) { |
| case CSSPropertyWebkitMarginCollapse: { |
| CSSValueID id = m_range.consumeIncludingWhitespace().id(); |
| if (!CSSParserFastPaths::isValidKeywordPropertyAndValue( |
| CSSPropertyWebkitMarginBeforeCollapse, id, m_context.mode())) |
| return false; |
| CSSValue* beforeCollapse = CSSIdentifierValue::create(id); |
| addProperty(CSSPropertyWebkitMarginBeforeCollapse, |
| CSSPropertyWebkitMarginCollapse, *beforeCollapse, important); |
| if (m_range.atEnd()) { |
| addProperty(CSSPropertyWebkitMarginAfterCollapse, |
| CSSPropertyWebkitMarginCollapse, *beforeCollapse, |
| important); |
| return true; |
| } |
| id = m_range.consumeIncludingWhitespace().id(); |
| if (!CSSParserFastPaths::isValidKeywordPropertyAndValue( |
| CSSPropertyWebkitMarginAfterCollapse, id, m_context.mode())) |
| return false; |
| addProperty(CSSPropertyWebkitMarginAfterCollapse, |
| CSSPropertyWebkitMarginCollapse, |
| *CSSIdentifierValue::create(id), important); |
| return true; |
| } |
| case CSSPropertyOverflow: { |
| CSSValueID id = m_range.consumeIncludingWhitespace().id(); |
| if (!CSSParserFastPaths::isValidKeywordPropertyAndValue( |
| CSSPropertyOverflowY, id, m_context.mode())) |
| return false; |
| if (!m_range.atEnd()) |
| return false; |
| CSSValue* overflowYValue = CSSIdentifierValue::create(id); |
| |
| CSSValue* overflowXValue = nullptr; |
| |
| // FIXME: -webkit-paged-x or -webkit-paged-y only apply to overflow-y. If |
| // this value has been set using the shorthand, then for now overflow-x |
| // will default to auto, but once we implement pagination controls, it |
| // should default to hidden. If the overflow-y value is anything but |
| // paged-x or paged-y, then overflow-x and overflow-y should have the same |
| // value. |
| if (id == CSSValueWebkitPagedX || id == CSSValueWebkitPagedY) |
| overflowXValue = CSSIdentifierValue::create(CSSValueAuto); |
| else |
| overflowXValue = overflowYValue; |
| addProperty(CSSPropertyOverflowX, CSSPropertyOverflow, *overflowXValue, |
| important); |
| addProperty(CSSPropertyOverflowY, CSSPropertyOverflow, *overflowYValue, |
| important); |
| return true; |
| } |
| case CSSPropertyFont: { |
| const CSSParserToken& token = m_range.peek(); |
| if (token.id() >= CSSValueCaption && token.id() <= CSSValueStatusBar) |
| return consumeSystemFont(important); |
| return consumeFont(important); |
| } |
| case CSSPropertyFontVariant: |
| return consumeFontVariantShorthand(important); |
| case CSSPropertyBorderSpacing: |
| return consumeBorderSpacing(important); |
| case CSSPropertyColumns: |
| return consumeColumns(important); |
| case CSSPropertyAnimation: |
| return consumeAnimationShorthand( |
| animationShorthandForParsing(), |
| unresolvedProperty == CSSPropertyAliasWebkitAnimation, important); |
| case CSSPropertyTransition: |
| return consumeAnimationShorthand(transitionShorthandForParsing(), false, |
| important); |
| case CSSPropertyTextDecoration: |
| ASSERT(RuntimeEnabledFeatures::css3TextDecorationsEnabled()); |
| return consumeShorthandGreedily(textDecorationShorthand(), important); |
| case CSSPropertyMargin: |
| return consume4Values(marginShorthand(), important); |
| case CSSPropertyPadding: |
| return consume4Values(paddingShorthand(), important); |
| case CSSPropertyMotion: |
| return consumeShorthandGreedily(motionShorthand(), important); |
| case CSSPropertyOffset: |
| return consumeOffsetShorthand(important); |
| case CSSPropertyWebkitTextEmphasis: |
| return consumeShorthandGreedily(webkitTextEmphasisShorthand(), important); |
| case CSSPropertyOutline: |
| return consumeShorthandGreedily(outlineShorthand(), important); |
| case CSSPropertyWebkitBorderStart: |
| return consumeShorthandGreedily(webkitBorderStartShorthand(), important); |
| case CSSPropertyWebkitBorderEnd: |
| return consumeShorthandGreedily(webkitBorderEndShorthand(), important); |
| case CSSPropertyWebkitBorderBefore: |
| return consumeShorthandGreedily(webkitBorderBeforeShorthand(), important); |
| case CSSPropertyWebkitBorderAfter: |
| return consumeShorthandGreedily(webkitBorderAfterShorthand(), important); |
| case CSSPropertyWebkitTextStroke: |
| return consumeShorthandGreedily(webkitTextStrokeShorthand(), important); |
| case CSSPropertyMarker: { |
| const CSSValue* marker = parseSingleValue(CSSPropertyMarkerStart); |
| if (!marker || !m_range.atEnd()) |
| return false; |
| addProperty(CSSPropertyMarkerStart, CSSPropertyMarker, *marker, |
| important); |
| addProperty(CSSPropertyMarkerMid, CSSPropertyMarker, *marker, important); |
| addProperty(CSSPropertyMarkerEnd, CSSPropertyMarker, *marker, important); |
| return true; |
| } |
| case CSSPropertyFlex: |
| return consumeFlex(important); |
| case CSSPropertyFlexFlow: |
| return consumeShorthandGreedily(flexFlowShorthand(), important); |
| case CSSPropertyColumnRule: |
| return consumeShorthandGreedily(columnRuleShorthand(), important); |
| case CSSPropertyListStyle: |
| return consumeShorthandGreedily(listStyleShorthand(), important); |
| case CSSPropertyBorderRadius: { |
| CSSValue* horizontalRadii[4] = {0}; |
| CSSValue* verticalRadii[4] = {0}; |
| if (!consumeRadii( |
| horizontalRadii, verticalRadii, m_range, m_context.mode(), |
| unresolvedProperty == CSSPropertyAliasWebkitBorderRadius)) |
| return false; |
| addProperty(CSSPropertyBorderTopLeftRadius, CSSPropertyBorderRadius, |
| *CSSValuePair::create(horizontalRadii[0], verticalRadii[0], |
| CSSValuePair::DropIdenticalValues), |
| important); |
| addProperty(CSSPropertyBorderTopRightRadius, CSSPropertyBorderRadius, |
| *CSSValuePair::create(horizontalRadii[1], verticalRadii[1], |
| CSSValuePair::DropIdenticalValues), |
| important); |
| addProperty(CSSPropertyBorderBottomRightRadius, CSSPropertyBorderRadius, |
| *CSSValuePair::create(horizontalRadii[2], verticalRadii[2], |
| CSSValuePair::DropIdenticalValues), |
| important); |
| addProperty(CSSPropertyBorderBottomLeftRadius, CSSPropertyBorderRadius, |
| *CSSValuePair::create(horizontalRadii[3], verticalRadii[3], |
| CSSValuePair::DropIdenticalValues), |
| important); |
| return true; |
| } |
| case CSSPropertyBorderColor: |
| return consume4Values(borderColorShorthand(), important); |
| case CSSPropertyBorderStyle: |
| return consume4Values(borderStyleShorthand(), important); |
| case CSSPropertyBorderWidth: |
| return consume4Values(borderWidthShorthand(), important); |
| case CSSPropertyBorderTop: |
| return consumeShorthandGreedily(borderTopShorthand(), important); |
| case CSSPropertyBorderRight: |
| return consumeShorthandGreedily(borderRightShorthand(), important); |
| case CSSPropertyBorderBottom: |
| return consumeShorthandGreedily(borderBottomShorthand(), important); |
| case CSSPropertyBorderLeft: |
| return consumeShorthandGreedily(borderLeftShorthand(), important); |
| case CSSPropertyBorder: |
| return consumeBorder(important); |
| case CSSPropertyBorderImage: |
| case CSSPropertyWebkitMaskBoxImage: |
| return consumeBorderImage(property, important); |
| case CSSPropertyPageBreakAfter: |
| case CSSPropertyPageBreakBefore: |
| case CSSPropertyPageBreakInside: |
| case CSSPropertyWebkitColumnBreakAfter: |
| case CSSPropertyWebkitColumnBreakBefore: |
| case CSSPropertyWebkitColumnBreakInside: |
| return consumeLegacyBreakProperty(property, important); |
| case CSSPropertyWebkitMaskPosition: |
| case CSSPropertyBackgroundPosition: { |
| CSSValue* resultX = nullptr; |
| CSSValue* resultY = nullptr; |
| if (!consumeBackgroundPosition(m_range, m_context, UnitlessQuirk::Allow, |
| resultX, resultY) || |
| !m_range.atEnd()) |
| return false; |
| addProperty(property == CSSPropertyBackgroundPosition |
| ? CSSPropertyBackgroundPositionX |
| : CSSPropertyWebkitMaskPositionX, |
| property, *resultX, important); |
| addProperty(property == CSSPropertyBackgroundPosition |
| ? CSSPropertyBackgroundPositionY |
| : CSSPropertyWebkitMaskPositionY, |
| property, *resultY, important); |
| return true; |
| } |
| case CSSPropertyBackgroundRepeat: |
| case CSSPropertyWebkitMaskRepeat: { |
| CSSValue* resultX = nullptr; |
| CSSValue* resultY = nullptr; |
| bool implicit = false; |
| if (!consumeRepeatStyle(m_range, resultX, resultY, implicit) || |
| !m_range.atEnd()) |
| return false; |
| addProperty(property == CSSPropertyBackgroundRepeat |
| ? CSSPropertyBackgroundRepeatX |
| : CSSPropertyWebkitMaskRepeatX, |
| property, *resultX, important, implicit); |
| addProperty(property == CSSPropertyBackgroundRepeat |
| ? CSSPropertyBackgroundRepeatY |
| : CSSPropertyWebkitMaskRepeatY, |
| property, *resultY, important, implicit); |
| return true; |
| } |
| case CSSPropertyBackground: |
| return consumeBackgroundShorthand(backgroundShorthand(), important); |
| case CSSPropertyWebkitMask: |
| return consumeBackgroundShorthand(webkitMaskShorthand(), important); |
| case CSSPropertyGridGap: { |
| ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled() && |
| shorthandForProperty(CSSPropertyGridGap).length() == 2); |
| CSSValue* rowGap = consumeLengthOrPercent(m_range, m_context.mode(), |
| ValueRangeNonNegative); |
| CSSValue* columnGap = consumeLengthOrPercent(m_range, m_context.mode(), |
| ValueRangeNonNegative); |
| if (!rowGap || !m_range.atEnd()) |
| return false; |
| if (!columnGap) |
| columnGap = rowGap; |
| addProperty(CSSPropertyGridRowGap, CSSPropertyGridGap, *rowGap, |
| important); |
| addProperty(CSSPropertyGridColumnGap, CSSPropertyGridGap, *columnGap, |
| important); |
| return true; |
| } |
| case CSSPropertyGridColumn: |
| case CSSPropertyGridRow: |
| return consumeGridItemPositionShorthand(property, important); |
| case CSSPropertyGridArea: |
| return consumeGridAreaShorthand(important); |
| case CSSPropertyGridTemplate: |
| return consumeGridTemplateShorthand(CSSPropertyGridTemplate, important); |
| case CSSPropertyGrid: |
| return consumeGridShorthand(important); |
| default: |
| return false; |
| } |
| } |
| |
| } // namespace blink |