Source/core/css/parser/CSSPropertyParser.cpp - Issue 1319343004: Add property parser code path based on CSSParserTokenRange

Unified Diff: Source/core/css/parser/CSSPropertyParser.cpp

Issue 1319343004: Add property parser code path based on CSSParserTokenRange (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master

Patch Set: Patch for landing Created 5 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: Source/core/css/parser/CSSPropertyParser.cpp

diff --git a/Source/core/css/parser/CSSPropertyParser.cpp b/Source/core/css/parser/CSSPropertyParser.cpp

index d08862af53cf57c0a7509af8f5495f06444435a7..2e6c483da002877dc8980b5b0be85f790357171b 100644

--- a/Source/core/css/parser/CSSPropertyParser.cpp

+++ b/Source/core/css/parser/CSSPropertyParser.cpp

@@ -1,83 +1,24 @@

-/*

- *

- * This library is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Library General Public

- * License as published by the Free Software Foundation; either

- * version 2 of the License, or (at your option) any later version.

- *

- * This library is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

- * Library General Public License for more details.

- *

- * You should have received a copy of the GNU Library General Public License

- * along with this library; see the file COPYING.LIB. If not, write to

- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

- * Boston, MA 02110-1301, USA.

- */

+// Use of this source code is governed by a BSD-style license that can be

+// found in the LICENSE file.

#include "config.h"

#include "core/css/parser/CSSPropertyParser.h"

#include "core/StylePropertyShorthand.h"

-#include "core/css/CSSBasicShapes.h"

-#include "core/css/CSSBorderImage.h"

-#include "core/css/CSSCanvasValue.h"

-#include "core/css/CSSContentDistributionValue.h"

-#include "core/css/CSSCounterValue.h"

-#include "core/css/CSSCrossfadeValue.h"

-#include "core/css/CSSCursorImageValue.h"

-#include "core/css/CSSFontFaceSrcValue.h"

-#include "core/css/CSSFontFeatureValue.h"

-#include "core/css/CSSFunctionValue.h"

-#include "core/css/CSSGridLineNamesValue.h"

-#include "core/css/CSSImageSetValue.h"

-#include "core/css/CSSImageValue.h"

-#include "core/css/CSSPathValue.h"

-#include "core/css/CSSPrimitiveValueMappings.h"

-#include "core/css/CSSProperty.h"

-#include "core/css/CSSPropertyMetadata.h"

-#include "core/css/CSSQuadValue.h"

-#include "core/css/CSSReflectValue.h"

-#include "core/css/CSSSVGDocumentValue.h"

-#include "core/css/CSSShadowValue.h"

-#include "core/css/CSSTimingFunctionValue.h"

-#include "core/css/CSSUnicodeRangeValue.h"

-#include "core/css/CSSValuePair.h"

+#include "core/css/CSSCalculationValue.h"

#include "core/css/CSSValuePool.h"

-#include "core/css/HashTools.h"

#include "core/css/parser/CSSParserFastPaths.h"

#include "core/css/parser/CSSParserValues.h"

#include "core/frame/UseCounter.h"

-#include "core/layout/LayoutTheme.h"

-#include "core/style/GridCoordinate.h"

-#include "core/svg/SVGPathUtilities.h"

-#include "platform/RuntimeEnabledFeatures.h"

namespace blink {

-template <unsigned N>

-static bool equalIgnoringCase(const CSSParserString& a, const char (&b)[N])

- unsigned length = N - 1; // Ignore the trailing null character

- if (a.length() != length)

- return false;

- return a.is8Bit() ? WTF::equalIgnoringCase(b, a.characters8(), length) : WTF::equalIgnoringCase(b, a.characters16(), length);

-CSSPropertyParser::CSSPropertyParser(CSSParserValueList* valueList,

+CSSPropertyParser::CSSPropertyParser(CSSParserValueList* valueList, const CSSParserTokenRange& range,

const CSSParserContext& context, WillBeHeapVector<CSSProperty, 256>& parsedProperties,

StyleRule::Type ruleType)

: m_valueList(valueList)

+ , m_range(range)

, m_context(context)

, m_parsedProperties(parsedProperties)

, m_ruleType(ruleType)

@@ -88,12 +29,15 @@ CSSPropertyParser::CSSPropertyParser(CSSParserValueList* valueList,

}

bool CSSPropertyParser::parseValue(CSSPropertyID unresolvedProperty, bool important,

- CSSParserValueList* valueList, const CSSParserContext& context,

+ const CSSParserTokenRange& range, const CSSParserContext& context,

WillBeHeapVector<CSSProperty, 256>& parsedProperties, StyleRule::Type ruleType)

{

int parsedPropertiesSize = parsedProperties.size();

- CSSPropertyParser parser(valueList, context, parsedProperties, ruleType);

+ CSSParserValueList valueList(range);

+ if (!valueList.size())

+ return false; // Parser error

+ CSSPropertyParser parser(&valueList, range, context, parsedProperties, ruleType);

CSSPropertyID resolvedProperty = resolveCSSPropertyID(unresolvedProperty);

bool parseSuccess;

@@ -116,392 +60,163 @@ bool CSSPropertyParser::parseValue(CSSPropertyID unresolvedProperty, bool import

return parseSuccess;

}

-void CSSPropertyParser::addProperty(CSSPropertyID propId, PassRefPtrWillBeRawPtr<CSSValue> value, bool important, bool implicit)

- ASSERT(!isPropertyAlias(propId));

- int shorthandIndex = 0;

- bool setFromShorthand = false;

- if (m_currentShorthand) {

- Vector<StylePropertyShorthand, 4> shorthands;

- getMatchingShorthandsForLonghand(propId, &shorthands);

- // Viewport descriptors have width and height as shorthands, but it doesn't

- // make sense for CSSProperties.in to consider them as such. The shorthand

- // index is only used by the inspector and doesn't affect viewport

- // descriptors.

- if (shorthands.isEmpty())

- ASSERT(m_currentShorthand == CSSPropertyWidth || m_currentShorthand == CSSPropertyHeight);

- else

- setFromShorthand = true;

- if (shorthands.size() > 1)

- shorthandIndex = indexOfShorthandForLonghand(m_currentShorthand, shorthands);

- }

- m_parsedProperties.append(CSSProperty(propId, value, important, setFromShorthand, shorthandIndex, m_implicitShorthand || implicit));

-void CSSPropertyParser::rollbackLastProperties(int num)

- ASSERT(num >= 0);

- ASSERT(m_parsedProperties.size() >= static_cast<unsigned>(num));

- m_parsedProperties.shrink(m_parsedProperties.size() - num);

-KURL CSSPropertyParser::completeURL(const String& url) const

- return m_context.completeURL(url);

-bool CSSPropertyParser::validCalculationUnit(CSSParserValue* value, Units unitflags, ReleaseParsedCalcValueCondition releaseCalc)

+// Helper methods for consuming tokens starts here.

+static bool consumeCommaIncludingWhitespace(CSSParserTokenRange& valueList)

{

- bool mustBeNonNegative = unitflags & (FNonNeg | FPositiveInteger);

- if (!parseCalculation(value, mustBeNonNegative ? ValueRangeNonNegative : ValueRangeAll))

+ CSSParserToken value = valueList.peek();

+ if (value.type() != CommaToken)

return false;

- bool b = false;

- switch (m_parsedCalculation->category()) {

- case CalcLength:

- b = (unitflags & FLength);

- break;

- case CalcNumber:

- b = (unitflags & FNumber);

- if (!b && (unitflags & (FInteger | FPositiveInteger)) && m_parsedCalculation->isInt())

- b = true;

- if (b && mustBeNonNegative && m_parsedCalculation->isNegative())

- b = false;

- // Always resolve calc() to a UnitType::Number in the CSSParserValue if there are no non-numbers specified in the unitflags.

- if (b && !(unitflags & ~(FInteger | FNumber | FPositiveInteger | FNonNeg))) {

- double number = m_parsedCalculation->doubleValue();

- if ((unitflags & FPositiveInteger) && number <= 0) {

- b = false;

- } else {

- delete value->calcFunction;

- value->setUnit(CSSPrimitiveValue::UnitType::Number);

- value->fValue = number;

- value->isInt = m_parsedCalculation->isInt();

- }

- m_parsedCalculation.release();

- return b;

- }

- break;

- case CalcPercent:

- b = (unitflags & FPercent);

- if (b && mustBeNonNegative && m_parsedCalculation->isNegative())

- b = false;

- break;

- case CalcPercentLength:

- b = (unitflags & FPercent) && (unitflags & FLength);

- break;

- case CalcPercentNumber:

- b = (unitflags & FPercent) && (unitflags & FNumber);

- break;

- case CalcAngle:

- b = (unitflags & FAngle);

- break;

- case CalcTime:

- b = (unitflags & FTime);

- break;

- case CalcFrequency:

- b = (unitflags & FFrequency);

- break;

- case CalcOther:

- break;

- }

- if (!b || releaseCalc == ReleaseParsedCalcValue)

- m_parsedCalculation.release();

- return b;

+ valueList.consumeIncludingWhitespace();

+ return true;

}

-inline bool CSSPropertyParser::shouldAcceptUnitLessValues(CSSParserValue* value, Units unitflags, CSSParserMode cssParserMode)

+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange& range)

{

- // Quirks mode for certain properties and presentation attributes accept unit-less values for certain units.

- return (unitflags & (FLength | FAngle))

- && (!value->fValue // 0 can always be unitless.

- || isUnitLessLengthParsingEnabledForMode(cssParserMode) // HTML and SVG attribute values can always be unitless.

- || (cssParserMode == HTMLQuirksMode && (unitflags & FUnitlessQuirk)));

+ if (range.peek().type() != IdentToken)

+ return nullptr;

+ return cssValuePool().createIdentifierValue(range.consumeIncludingWhitespace().id());

}

-inline bool isCalculation(CSSParserValue* value)

+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeCustomIdent(CSSParserTokenRange& range)

{

- return value->m_unit == CSSParserValue::CalcFunction;

+ if (range.peek().type() != IdentToken)

+ return nullptr;

+ return cssValuePool().createValue(range.consumeIncludingWhitespace().value(), CSSPrimitiveValue::UnitType::CustomIdentifier);

}

-bool CSSPropertyParser::validUnit(CSSParserValue* value, Units unitflags, CSSParserMode cssParserMode, ReleaseParsedCalcValueCondition releaseCalc)

+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeString(CSSParserTokenRange& range)

{

- if (isCalculation(value))

- return validCalculationUnit(value, unitflags, releaseCalc);

- if (unitflags & FNonNeg && value->fValue < 0)

- return false;

- switch (value->unit()) {

- case CSSPrimitiveValue::UnitType::Number:

- if (unitflags & FNumber)

- return true;

- if (shouldAcceptUnitLessValues(value, unitflags, cssParserMode)) {

- value->setUnit((unitflags & FLength) ? CSSPrimitiveValue::UnitType::Pixels : CSSPrimitiveValue::UnitType::Degrees);

- return true;

- }

- if ((unitflags & FInteger) && value->isInt)

- return true;

- if ((unitflags & FPositiveInteger) && value->isInt && value->fValue > 0)

- return true;

- return false;

- case CSSPrimitiveValue::UnitType::Percentage:

- return unitflags & FPercent;

- case CSSPrimitiveValue::UnitType::QuirkyEms:

- if (cssParserMode != UASheetMode)

- return false;

- /* fallthrough intentional */

- case CSSPrimitiveValue::UnitType::Ems:

- case CSSPrimitiveValue::UnitType::Rems:

- case CSSPrimitiveValue::UnitType::Chs:

- case CSSPrimitiveValue::UnitType::Exs:

- case CSSPrimitiveValue::UnitType::Pixels:

- case CSSPrimitiveValue::UnitType::Centimeters:

- case CSSPrimitiveValue::UnitType::Millimeters:

- case CSSPrimitiveValue::UnitType::Inches:

- case CSSPrimitiveValue::UnitType::Points:

- case CSSPrimitiveValue::UnitType::Picas:

- case CSSPrimitiveValue::UnitType::ViewportWidth:

- case CSSPrimitiveValue::UnitType::ViewportHeight:

- case CSSPrimitiveValue::UnitType::ViewportMin:

- case CSSPrimitiveValue::UnitType::ViewportMax:

- return unitflags & FLength;

- case CSSPrimitiveValue::UnitType::Milliseconds:

- case CSSPrimitiveValue::UnitType::Seconds:

- return unitflags & FTime;

- case CSSPrimitiveValue::UnitType::Degrees:

- case CSSPrimitiveValue::UnitType::Radians:

- case CSSPrimitiveValue::UnitType::Gradians:

- case CSSPrimitiveValue::UnitType::Turns:

- return unitflags & FAngle;

- case CSSPrimitiveValue::UnitType::DotsPerPixel:

- case CSSPrimitiveValue::UnitType::DotsPerInch:

- case CSSPrimitiveValue::UnitType::DotsPerCentimeter:

- return unitflags & FResolution;

- default:

- return false;

- }

+ if (range.peek().type() != StringToken)

+ return nullptr;

+ return cssValuePool().createValue(range.consumeIncludingWhitespace().value(), CSSPrimitiveValue::UnitType::String);

}

-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveNumericValue(CSSParserValue* value)

+// Methods for consuming non-shorthand properties starts here.

+static PassRefPtrWillBeRawPtr<CSSValue> consumeWillChange(CSSParserTokenRange& range)

{

- if (m_parsedCalculation) {

- ASSERT(isCalculation(value));

- return CSSPrimitiveValue::create(m_parsedCalculation.release());

+ RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();

+ if (range.peek().id() == CSSValueAuto) {

+ // FIXME: This will be read back as an empty string instead of auto

+ return values.release();

}

- ASSERT((value->unit() >= CSSPrimitiveValue::UnitType::Number && value->unit() <= CSSPrimitiveValue::UnitType::Kilohertz)

- || (value->unit() >= CSSPrimitiveValue::UnitType::Turns && value->unit() <= CSSPrimitiveValue::UnitType::Chs)

- || (value->unit() >= CSSPrimitiveValue::UnitType::ViewportWidth && value->unit() <= CSSPrimitiveValue::UnitType::ViewportMax)

- || (value->unit() >= CSSPrimitiveValue::UnitType::DotsPerPixel && value->unit() <= CSSPrimitiveValue::UnitType::DotsPerCentimeter));

- return cssValuePool().createValue(value->fValue, value->unit());

-inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveStringValue(CSSParserValue* value)

- ASSERT(value->unit() == CSSPrimitiveValue::UnitType::String || value->m_unit == CSSParserValue::Identifier);

- return cssValuePool().createValue(value->string, CSSPrimitiveValue::UnitType::String);

-inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveCustomIdentValue(CSSParserValue* value)

- ASSERT(value->unit() == CSSPrimitiveValue::UnitType::String || value->m_unit == CSSParserValue::Identifier);

- return cssValuePool().createValue(value->string, CSSPrimitiveValue::UnitType::CustomIdentifier);

-inline PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::createCSSImageValueWithReferrer(const String& rawValue, const KURL& url)

- RefPtrWillBeRawPtr<CSSValue> imageValue = CSSImageValue::create(rawValue, url);

- toCSSImageValue(imageValue.get())->setReferrer(m_context.referrer());

- return imageValue;

-static inline bool isComma(CSSParserValue* value)

- ASSERT(value);

- return value->m_unit == CSSParserValue::Operator && value->iValue == ',';

-static bool consumeComma(CSSParserValueList* valueList)

- CSSParserValue* value = valueList->current();

- if (!value || !isComma(value))

- return false;

- valueList->next();

- return true;

-static inline bool isForwardSlashOperator(CSSParserValue* value)

- ASSERT(value);

- return value->m_unit == CSSParserValue::Operator && value->iValue == '/';

-static bool isGeneratedImageValue(CSSParserValue* val)

- if (val->m_unit != CSSParserValue::Function)

- return false;

- CSSValueID id = val->function->id;

- return id == CSSValueLinearGradient

- || id == CSSValueRadialGradient

- || id == CSSValueRepeatingLinearGradient

- || id == CSSValueRepeatingRadialGradient

- || id == CSSValueWebkitLinearGradient

- || id == CSSValueWebkitRadialGradient

- || id == CSSValueWebkitRepeatingLinearGradient

- || id == CSSValueWebkitRepeatingRadialGradient

- || id == CSSValueWebkitGradient

- || id == CSSValueWebkitCanvas

- || id == CSSValueWebkitCrossFade;

-bool CSSPropertyParser::validWidthOrHeight(CSSParserValue* value, Units unitless)

- int id = value->id;

- if (id == CSSValueIntrinsic || id == CSSValueMinIntrinsic

- || id == CSSValueWebkitMinContent || id == CSSValueWebkitMaxContent || id == CSSValueWebkitFillAvailable || id == CSSValueWebkitFitContent

- || id == CSSValueMinContent || id == CSSValueMaxContent || id == CSSValueFitContent) {

- if (m_context.useCounter()) {

- switch (value->id) {

- case CSSValueIntrinsic:

- m_context.useCounter()->count(UseCounter::LegacyCSSValueIntrinsic);

- break;

- case CSSValueMinIntrinsic:

- m_context.useCounter()->count(UseCounter::LegacyCSSValueMinIntrinsic);

- break;

- case CSSValueWebkitMinContent:

- m_context.useCounter()->count(UseCounter::CSSValuePrefixedMinContent);

- break;

- case CSSValueWebkitMaxContent:

- m_context.useCounter()->count(UseCounter::CSSValuePrefixedMaxContent);

- break;

- case CSSValueWebkitFillAvailable:

- m_context.useCounter()->count(UseCounter::CSSValuePrefixedFillAvailable);

- break;

- case CSSValueWebkitFitContent:

- m_context.useCounter()->count(UseCounter::CSSValuePrefixedFitContent);

+ // 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) {

+ 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(cssValuePool().createIdentifierValue(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;

}

- return true;

+ if (range.atEnd())

+ break;

+ if (!consumeCommaIncludingWhitespace(range))

+ return nullptr;

}

- return validUnit(value, FLength | FPercent | FNonNeg | unitless);

+ return values.release();

}

-inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseValidPrimitive(CSSValueID identifier, CSSParserValue* value)

+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumePage(CSSParserTokenRange& range)

{

- if (identifier)

- return cssValuePool().createIdentifierValue(identifier);

- if (value->unit() >= CSSPrimitiveValue::UnitType::Number && value->unit() <= CSSPrimitiveValue::UnitType::Kilohertz)

- return createPrimitiveNumericValue(value);

- if (value->unit() >= CSSPrimitiveValue::UnitType::Turns && value->unit() <= CSSPrimitiveValue::UnitType::Chs)

- return createPrimitiveNumericValue(value);

- if (value->unit() >= CSSPrimitiveValue::UnitType::ViewportWidth && value->unit() <= CSSPrimitiveValue::UnitType::ViewportMax)

- return createPrimitiveNumericValue(value);

- if (value->unit() >= CSSPrimitiveValue::UnitType::DotsPerPixel && value->unit() <= CSSPrimitiveValue::UnitType::DotsPerCentimeter)

- return createPrimitiveNumericValue(value);

- if (value->unit() == CSSPrimitiveValue::UnitType::QuirkyEms)

- return CSSPrimitiveValue::create(value->fValue, CSSPrimitiveValue::UnitType::QuirkyEms);

- if (isCalculation(value))

- return CSSPrimitiveValue::create(m_parsedCalculation.release());

- return nullptr;

+ if (range.peek().id() == CSSValueAuto)

+ return consumeIdent(range);

+ return consumeCustomIdent(range);

}

-void CSSPropertyParser::addExpandedPropertyForValue(CSSPropertyID propId, PassRefPtrWillBeRawPtr<CSSValue> prpValue, bool important)

+// [ <string> <string> ]+ | none

+static PassRefPtrWillBeRawPtr<CSSValue> consumeQuotes(CSSParserTokenRange& range)

{

- const StylePropertyShorthand& shorthand = shorthandForProperty(propId);

- unsigned shorthandLength = shorthand.length();

- if (!shorthandLength) {

- addProperty(propId, prpValue, important);

- return;

+ if (range.peek().id() == CSSValueNone)

+ return consumeIdent(range);

+ RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();

+ while (!range.atEnd()) {

+ RefPtrWillBeRawPtr<CSSValue> parsedValue = consumeString(range);

+ if (!parsedValue)

+ return nullptr;

+ values->append(parsedValue.release());

}

- RefPtrWillBeRawPtr<CSSValue> value = prpValue;

- ShorthandScope scope(this, propId);

- const CSSPropertyID* longhands = shorthand.properties();

- for (unsigned i = 0; i < shorthandLength; ++i)

- addProperty(longhands[i], value, important);

+ if (values->length() && values->length() % 2 == 0)

+ return values.release();

+ return nullptr;

}

-bool CSSPropertyParser::parseValue(CSSPropertyID unresolvedProperty, bool important)

+static PassRefPtrWillBeRawPtr<CSSValue> consumeWebkitHighlight(CSSParserTokenRange& range)

{

- CSSPropertyID propId = resolveCSSPropertyID(unresolvedProperty);

- CSSParserValue* value = m_valueList->current();

- // Note: m_parsedCalculation is used to pass the calc value to validUnit and then cleared at the end of this function.

- // FIXME: This is to avoid having to pass parsedCalc to all validUnit callers.

- ASSERT(!m_parsedCalculation);

- CSSValueID id = value->id;

+ if (range.peek().id() == CSSValueNone)

+ return consumeIdent(range);

+ return consumeString(range);

- if (id == CSSValueInherit) {

- if (m_valueList->size() != 1)

- return false;

- addExpandedPropertyForValue(propId, cssValuePool().createInheritedValue(), important);

- return true;

- } else if (id == CSSValueInitial) {

- if (m_valueList->size() != 1)

- return false;

- addExpandedPropertyForValue(propId, cssValuePool().createExplicitInitialValue(), important);

- return true;

- } else if (id == CSSValueUnset) {

- if (m_valueList->size() != 1)

- return false;

- addExpandedPropertyForValue(propId, cssValuePool().createUnsetValue(), important);

- return true;

+PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID propId)

+ m_range.consumeWhitespace();

+ switch (propId) {

+ case CSSPropertyWillChange:

+ return consumeWillChange(m_range);

+ case CSSPropertyPage:

+ return consumePage(m_range);

+ case CSSPropertyQuotes:

+ return consumeQuotes(m_range);

+ case CSSPropertyWebkitHighlight:

+ return consumeWebkitHighlight(m_range);

+ default:

+ return nullptr;

}

- if (CSSParserFastPaths::isKeywordPropertyID(propId)) {

- if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(propId, id))

+bool CSSPropertyParser::parseShorthand(CSSPropertyID propId, bool important)

+ m_range.consumeWhitespace();

+ switch (propId) {

+ case CSSPropertyWebkitMarginCollapse: {

+ CSSValueID id = m_range.consumeIncludingWhitespace().id();

+ if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyWebkitMarginBeforeCollapse, id))

return false;

- if (m_valueList->next() && !inShorthand())

+ RefPtrWillBeRawPtr<CSSValue> beforeCollapse = cssValuePool().createIdentifierValue(id);

+ addProperty(CSSPropertyWebkitMarginBeforeCollapse, beforeCollapse, important);

+ if (m_range.atEnd()) {

+ addProperty(CSSPropertyWebkitMarginAfterCollapse, beforeCollapse, important);

+ return true;

+ }

+ id = m_range.consumeIncludingWhitespace().id();

+ if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyWebkitMarginAfterCollapse, id))

return false;

- addProperty(propId, cssValuePool().createIdentifierValue(id), important);

+ addProperty(CSSPropertyWebkitMarginAfterCollapse, cssValuePool().createIdentifierValue(id), important);

return true;

}

- bool validPrimitive = false;

- Units unitless = FUnknown;

- RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;

- switch (propId) {

- case CSSPropertySize: // <length>{1,2} | auto | [ <page-size> || [ portrait | landscape] ]

- parsedValue = parseSize();

- break;

- case CSSPropertyQuotes: // [<string> <string>]+ | none

- if (id == CSSValueNone)

- validPrimitive = true;

- else

- parsedValue = parseQuotes();

- break;

- // close-quote | no-open-quote | no-close-quote ]+ | inherit

- parsedValue = parseContent();

- break;

- case CSSPropertyClip: // <shape> | auto | inherit

- if (id == CSSValueAuto)

- validPrimitive = true;

- else if (value->m_unit == CSSParserValue::Function)

- parsedValue = parseClipShape();

- break;

- /* Start of supported CSS properties with validation. This is needed for parseShorthand to work

- * correctly and allows optimization in blink::applyRule(..)

- */

case CSSPropertyOverflow: {

- ShorthandScope scope(this, propId);

- if (!parseValue(CSSPropertyOverflowY, important) || m_valueList->current())

+ CSSValueID id = m_range.consumeIncludingWhitespace().id();

+ if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyOverflowY, id))

+ return false;

+ if (!m_range.atEnd())

return false;

+ RefPtrWillBeRawPtr<CSSValue> overflowYValue = cssValuePool().createIdentifierValue(id);

RefPtrWillBeRawPtr<CSSValue> overflowXValue = nullptr;

@@ -512,7439 +227,14 @@ bool CSSPropertyParser::parseValue(CSSPropertyID unresolvedProperty, bool import

if (id == CSSValueWebkitPagedX || id == CSSValueWebkitPagedY)

overflowXValue = cssValuePool().createIdentifierValue(CSSValueAuto);

else

- overflowXValue = m_parsedProperties.last().value();

+ overflowXValue = overflowYValue;

addProperty(CSSPropertyOverflowX, overflowXValue.release(), important);

+ addProperty(CSSPropertyOverflowY, overflowYValue.release(), important);

return true;

}

- case CSSPropertyTextAlign:

- // FIXME: <string> not supported right now

- if ((id >= CSSValueWebkitAuto && id <= CSSValueWebkitMatchParent) || id == CSSValueStart || id == CSSValueEnd) {

- validPrimitive = true;

- }

- break;

- case CSSPropertyFontWeight: // normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | inherit

- return parseFontWeight(important) && !m_valueList->next();

- case CSSPropertyBorderSpacing: {

- ShorthandScope scope(this, CSSPropertyBorderSpacing);

- if (!parseValue(CSSPropertyWebkitBorderHorizontalSpacing, important))

- return false;

- if (!m_valueList->current()) {

- CSSValue* value = m_parsedProperties.last().value();

- addProperty(CSSPropertyWebkitBorderVerticalSpacing, value, important);

- return true;

- }

- if (!parseValue(CSSPropertyWebkitBorderVerticalSpacing, important))

- return false;

- return !m_valueList->current();

- }

- case CSSPropertyWebkitBorderHorizontalSpacing:

- case CSSPropertyWebkitBorderVerticalSpacing:

- unitless = FLength | FNonNeg;

- if (inShorthand() && m_currentShorthand == CSSPropertyBorderSpacing)

- unitless = unitless | FUnitlessQuirk;

- validPrimitive = validUnit(value, unitless);

- break;

- case CSSPropertyOutlineColor: // <color> | invert | inherit

- // Outline color has "invert" as additional keyword.

- // Also, we want to allow the special focus color even in HTML Standard parsing mode.

- if (id == CSSValueInvert || id == CSSValueWebkitFocusRingColor) {

- validPrimitive = true;

- break;

- }

- /* nobreak */

- case CSSPropertyBackgroundColor: // <color> | inherit

- case CSSPropertyBorderTopColor: // <color> | inherit

- case CSSPropertyBorderRightColor:

- case CSSPropertyBorderBottomColor:

- case CSSPropertyBorderLeftColor:

- case CSSPropertyWebkitBorderStartColor:

- case CSSPropertyWebkitBorderEndColor:

- case CSSPropertyWebkitBorderBeforeColor:

- case CSSPropertyWebkitBorderAfterColor:

- case CSSPropertyColor: // <color> | inherit

- case CSSPropertyTextDecorationColor: // CSS3 text decoration colors

- case CSSPropertyWebkitColumnRuleColor:

- case CSSPropertyWebkitTextEmphasisColor:

- case CSSPropertyWebkitTextFillColor:

- case CSSPropertyWebkitTextStrokeColor:

- ASSERT(propId != CSSPropertyTextDecorationColor || RuntimeEnabledFeatures::css3TextDecorationsEnabled());

- parsedValue = parseColor(m_valueList->current(), acceptQuirkyColors(propId));

- if (parsedValue)

- m_valueList->next();

- break;

- case CSSPropertyCursor: {

- // Grammar defined by CSS3 UI and modified by CSS4 images:

- // [ [<image> [<x> <y>]?,]*

- RefPtrWillBeRawPtr<CSSValueList> list = nullptr;

- while (value) {

- RefPtrWillBeRawPtr<CSSValue> image = nullptr;

- if (value->unit() == CSSPrimitiveValue::UnitType::URI) {

- String uri = value->string;

- if (!uri.isNull())

- image = createCSSImageValueWithReferrer(uri, completeURL(uri));

- } else if (value->m_unit == CSSParserValue::Function && value->function->id == CSSValueWebkitImageSet) {

- image = parseImageSet(m_valueList);

- if (!image)

- break;

- } else

- break;

- Vector<int> coords;

- value = m_valueList->next();

- while (value && validUnit(value, FNumber)) {

- coords.append(int(value->fValue));

- value = m_valueList->next();

- }

- bool hotSpotSpecified = false;

- IntPoint hotSpot(-1, -1);

- int nrcoords = coords.size();

- if (nrcoords > 0 && nrcoords != 2)

- return false;

- if (nrcoords == 2) {

- hotSpotSpecified = true;

- hotSpot = IntPoint(coords[0], coords[1]);

- }

- if (!list)

- list = CSSValueList::createCommaSeparated();

- if (image)

- list->append(CSSCursorImageValue::create(image, hotSpotSpecified, hotSpot));

- if (!consumeComma(m_valueList))

- return false;

- value = m_valueList->current();

- }

- if (value && m_context.useCounter()) {

- if (value->id == CSSValueWebkitZoomIn)

- m_context.useCounter()->count(UseCounter::PrefixedCursorZoomIn);

- else if (value->id == CSSValueWebkitZoomOut)

- m_context.useCounter()->count(UseCounter::PrefixedCursorZoomOut);

- }

- if (list) {

- if (!value)

- return false;

- if (inQuirksMode() && value->id == CSSValueHand) // MSIE 5 compatibility :/

- list->append(cssValuePool().createIdentifierValue(CSSValuePointer));

- else if ((value->id >= CSSValueAuto && value->id <= CSSValueWebkitZoomOut) || value->id == CSSValueCopy || value->id == CSSValueNone)

- list->append(cssValuePool().createIdentifierValue(value->id));

- m_valueList->next();

- parsedValue = list.release();

- break;

- } else if (value) {

- id = value->id;

- if (inQuirksMode() && value->id == CSSValueHand) { // MSIE 5 compatibility :/

- id = CSSValuePointer;

- validPrimitive = true;

- } else if ((value->id >= CSSValueAuto && value->id <= CSSValueWebkitZoomOut) || value->id == CSSValueCopy || value->id == CSSValueNone)

- validPrimitive = true;

- } else {

- ASSERT_NOT_REACHED();

- return false;

- }

- break;

- }

- case CSSPropertyImageOrientation:

- if (RuntimeEnabledFeatures::imageOrientationEnabled())

- validPrimitive = value->id == CSSValueFromImage || (value->unit() != CSSPrimitiveValue::UnitType::Number && validUnit(value, FAngle) && value->fValue == 0);

- break;

- case CSSPropertyBackgroundBlendMode:

- case CSSPropertyBackgroundAttachment:

- case CSSPropertyBackgroundClip:

- case CSSPropertyWebkitBackgroundClip:

- case CSSPropertyWebkitBackgroundComposite:

- case CSSPropertyBackgroundImage:

- case CSSPropertyBackgroundOrigin:

- case CSSPropertyMaskSourceType:

- case CSSPropertyWebkitBackgroundOrigin:

- case CSSPropertyBackgroundPosition:

- case CSSPropertyBackgroundPositionX:

- case CSSPropertyBackgroundPositionY:

- case CSSPropertyBackgroundSize:

- case CSSPropertyBackgroundRepeat:

- case CSSPropertyWebkitMaskClip:

- case CSSPropertyWebkitMaskComposite:

- case CSSPropertyWebkitMaskImage:

- case CSSPropertyWebkitMaskOrigin:

- case CSSPropertyWebkitMaskPosition:

- case CSSPropertyWebkitMaskPositionX:

- case CSSPropertyWebkitMaskPositionY:

- case CSSPropertyWebkitMaskSize:

- case CSSPropertyWebkitMaskRepeat:

- case CSSPropertyWebkitMaskRepeatX:

- case CSSPropertyWebkitMaskRepeatY:

- {

- RefPtrWillBeRawPtr<CSSValue> val1 = nullptr;

- RefPtrWillBeRawPtr<CSSValue> val2 = nullptr;

- CSSPropertyID propId1, propId2;

- bool result = false;

- if (parseFillProperty(unresolvedProperty, propId1, propId2, val1, val2)) {

- if (propId == CSSPropertyBackgroundPosition ||

- propId == CSSPropertyBackgroundRepeat ||

- propId == CSSPropertyWebkitMaskPosition ||

- propId == CSSPropertyWebkitMaskRepeat) {

- ShorthandScope scope(this, propId);

- addProperty(propId1, val1.release(), important);

- if (val2)

- addProperty(propId2, val2.release(), important);

- } else {

- addProperty(propId1, val1.release(), important);

- if (val2)

- addProperty(propId2, val2.release(), important);

- }

- result = true;

- }

- m_implicitShorthand = false;

- return result;

- }

- case CSSPropertyObjectPosition:

- parsedValue = parsePosition(m_valueList);

- break;

- case CSSPropertyListStyleImage: // <uri> | none | inherit

- case CSSPropertyBorderImageSource:

- case CSSPropertyWebkitMaskBoxImageSource:

- if (id == CSSValueNone) {

- parsedValue = cssValuePool().createIdentifierValue(CSSValueNone);

- m_valueList->next();

- } else if (value->unit() == CSSPrimitiveValue::UnitType::URI) {

- parsedValue = createCSSImageValueWithReferrer(value->string, completeURL(value->string));

- m_valueList->next();

- } else if (isGeneratedImageValue(value)) {

- if (parseGeneratedImage(m_valueList, parsedValue))

- m_valueList->next();

- else

- return false;

- } else if (value->m_unit == CSSParserValue::Function && value->function->id == CSSValueWebkitImageSet) {

- parsedValue = parseImageSet(m_valueList);

- if (!parsedValue)

- return false;

- m_valueList->next();

- }

- break;

- case CSSPropertyBorderTopWidth: //// <border-width> | inherit

- case CSSPropertyBorderRightWidth: // Which is defined as

- case CSSPropertyBorderBottomWidth: // thin | medium | thick | <length>

- case CSSPropertyBorderLeftWidth:

- if (!inShorthand() || m_currentShorthand == CSSPropertyBorderWidth)

- unitless = FUnitlessQuirk;

- // fall through

- case CSSPropertyWebkitTextStrokeWidth:

- case CSSPropertyOutlineWidth: // <border-width> | inherit

- case CSSPropertyWebkitBorderStartWidth:

- case CSSPropertyWebkitBorderEndWidth:

- case CSSPropertyWebkitBorderBeforeWidth:

- case CSSPropertyWebkitBorderAfterWidth:

- case CSSPropertyWebkitColumnRuleWidth:

- if (id == CSSValueThin || id == CSSValueMedium || id == CSSValueThick)

- validPrimitive = true;

- else

- validPrimitive = validUnit(value, FLength | FNonNeg | unitless);

- break;

- case CSSPropertyLetterSpacing: // normal | <length> | inherit

- case CSSPropertyWordSpacing: // normal | <length> | inherit

- if (id == CSSValueNormal)

- validPrimitive = true;

- else

- validPrimitive = validUnit(value, FLength | FUnitlessQuirk);

- break;

- case CSSPropertyTextIndent:

- parsedValue = parseTextIndent();

- break;

- case CSSPropertyPaddingTop: //// <padding-width> | inherit

- case CSSPropertyPaddingRight: // Which is defined as

- case CSSPropertyPaddingBottom: // <length> | <percentage>

- case CSSPropertyPaddingLeft: ////

- unitless = FUnitlessQuirk;

- // fall through

- case CSSPropertyWebkitPaddingStart:

- case CSSPropertyWebkitPaddingEnd:

- case CSSPropertyWebkitPaddingBefore:

- case CSSPropertyWebkitPaddingAfter:

- validPrimitive = validUnit(value, FLength | FPercent | FNonNeg | unitless);

- break;

- case CSSPropertyMaxWidth:

- case CSSPropertyMaxHeight:

- unitless = FUnitlessQuirk;

- // fall through

- case CSSPropertyWebkitMaxLogicalWidth:

- case CSSPropertyWebkitMaxLogicalHeight:

- validPrimitive = (id == CSSValueNone || validWidthOrHeight(value, unitless));

- break;

- case CSSPropertyMinWidth:

- case CSSPropertyMinHeight:

- case CSSPropertyWidth:

- case CSSPropertyHeight:

- unitless = FUnitlessQuirk;

- // fall through

- case CSSPropertyWebkitMinLogicalWidth:

- case CSSPropertyWebkitMinLogicalHeight:

- case CSSPropertyWebkitLogicalWidth:

- case CSSPropertyWebkitLogicalHeight:

- validPrimitive = (id == CSSValueAuto || validWidthOrHeight(value, unitless));

- break;

- case CSSPropertyFontSize:

- return parseFontSize(important);

- case CSSPropertyFontVariant: // normal | small-caps | inherit

- return parseFontVariant(important);

- case CSSPropertyVerticalAlign:

- // <percentage> | <length> | inherit

- if (id >= CSSValueBaseline && id <= CSSValueWebkitBaselineMiddle)

- validPrimitive = true;

- else

- validPrimitive = validUnit(value, FLength | FPercent | FUnitlessQuirk);

- break;

- case CSSPropertyBottom: // <length> | <percentage> | auto | inherit

- case CSSPropertyLeft: // <length> | <percentage> | auto | inherit

- case CSSPropertyRight: // <length> | <percentage> | auto | inherit

- case CSSPropertyTop: // <length> | <percentage> | auto | inherit

- case CSSPropertyMarginTop: //// <margin-width> | inherit

- case CSSPropertyMarginRight: // Which is defined as

- case CSSPropertyMarginBottom: // <length> | <percentage> | auto | inherit

- case CSSPropertyMarginLeft: ////

- unitless = FUnitlessQuirk;

- // fall through

- case CSSPropertyWebkitMarginStart:

- case CSSPropertyWebkitMarginEnd:

- case CSSPropertyWebkitMarginBefore:

- case CSSPropertyWebkitMarginAfter:

- if (id == CSSValueAuto)

- validPrimitive = true;

- else

- validPrimitive = validUnit(value, FLength | FPercent | unitless);

- break;

- case CSSPropertyOrphans: // <integer> | inherit | auto (We've added support for auto for backwards compatibility)

- case CSSPropertyWidows: // <integer> | inherit | auto (Ditto)

- if (id == CSSValueAuto)

- validPrimitive = true;

- else

- validPrimitive = validUnit(value, FPositiveInteger);

- break;

- case CSSPropertyZIndex: // auto | <integer> | inherit

- if (id == CSSValueAuto) {

- validPrimitive = true;

- } else if (validUnit(value, FInteger)) {

- addProperty(propId, cssValuePool().createValue(value->fValue, CSSPrimitiveValue::UnitType::Integer), important);

- return true;

- }

- break;

- case CSSPropertyLineHeight:

- parsedValue = parseLineHeight();

- break;

- case CSSPropertyCounterIncrement:

- if (id == CSSValueNone)

- validPrimitive = true;

- else

- parsedValue = parseCounter(1);

- break;

- case CSSPropertyCounterReset:

- if (id == CSSValueNone)

- validPrimitive = true;

- else

- parsedValue = parseCounter(0);

- break;

- case CSSPropertyFontFamily:

- // [[ <family-name> | <generic-family> ],]* [<family-name> | <generic-family>] | inherit

- {

- parsedValue = parseFontFamily();

- break;

- }

- case CSSPropertyTextDecoration:

- // Fall through 'text-decoration-line' parsing if CSS 3 Text Decoration

- // is disabled to match CSS 2.1 rules for parsing 'text-decoration'.

- if (RuntimeEnabledFeatures::css3TextDecorationsEnabled()) {

- // [ <text-decoration-line> || <text-decoration-style> || <text-decoration-color> ] | inherit

- return parseShorthand(CSSPropertyTextDecoration, textDecorationShorthand(), important);

- }

- case CSSPropertyWebkitTextDecorationsInEffect:

- case CSSPropertyTextDecorationLine:

- // none | [ underline || overline || line-through || blink ] | inherit

- parsedValue = parseTextDecoration();

- break;

- case CSSPropertyTextUnderlinePosition:

- // auto | [ under || [ left | right ] ], but we only support auto | under for now

- ASSERT(RuntimeEnabledFeatures::css3TextDecorationsEnabled());

- validPrimitive = (id == CSSValueAuto || id == CSSValueUnder);

- break;

- if (id == CSSValueNormal || id == CSSValueReset || id == CSSValueDocument)

- validPrimitive = true;

- else

- validPrimitive = validUnit(value, FNumber | FPercent | FNonNeg);

- if (validPrimitive && m_context.useCounter()

- && !(id == CSSValueNormal

- || (value->unit() == CSSPrimitiveValue::UnitType::Number && value->fValue == 1)

- || (value->unit() == CSSPrimitiveValue::UnitType::Percentage && value->fValue == 100)))

- m_context.useCounter()->count(UseCounter::CSSZoomNotEqualToOne);

- break;

- case CSSPropertySrc:

- case CSSPropertyUnicodeRange:

- /* @font-face only descriptors */

- break;

- /* CSS3 properties */

- case CSSPropertyBorderImage:

- case CSSPropertyWebkitMaskBoxImage:

- return parseBorderImageShorthand(propId, important);

- case CSSPropertyWebkitBorderImage: {

- if (RefPtrWillBeRawPtr<CSSValue> result = parseBorderImage(propId)) {

- addProperty(propId, result, important);

- return true;

- }

+ default:

return false;

}

- case CSSPropertyBorderImageOutset:

- case CSSPropertyWebkitMaskBoxImageOutset: {

- RefPtrWillBeRawPtr<CSSQuadValue> result = nullptr;

- if (parseBorderImageOutset(result)) {

- addProperty(propId, result, important);

- return true;

- }

- break;

- }

- case CSSPropertyBorderImageRepeat:

- case CSSPropertyWebkitMaskBoxImageRepeat: {

- RefPtrWillBeRawPtr<CSSValue> result = nullptr;

- if (parseBorderImageRepeat(result)) {

- addProperty(propId, result, important);

- return true;

- }

- break;

- }

- case CSSPropertyBorderImageSlice:

- case CSSPropertyWebkitMaskBoxImageSlice: {

- RefPtrWillBeRawPtr<CSSBorderImageSliceValue> result = nullptr;

- if (parseBorderImageSlice(propId, result)) {

- addProperty(propId, result, important);

- return true;

- }

- break;

- }

- case CSSPropertyBorderImageWidth:

- case CSSPropertyWebkitMaskBoxImageWidth: {

- RefPtrWillBeRawPtr<CSSQuadValue> result = nullptr;

- if (parseBorderImageWidth(result)) {

- addProperty(propId, result, important);

- return true;

- }

- break;

- }

- case CSSPropertyBorderTopRightRadius:

- case CSSPropertyBorderTopLeftRadius:

- case CSSPropertyBorderBottomLeftRadius:

- case CSSPropertyBorderBottomRightRadius: {

- validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);

- if (!validPrimitive)

- return false;

- RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1 = createPrimitiveNumericValue(value);

- RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2 = nullptr;

- value = m_valueList->next();

- if (value) {

- validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);

- if (!validPrimitive)

- return false;

- parsedValue2 = createPrimitiveNumericValue(value);

- } else

- parsedValue2 = parsedValue1;

- if (m_valueList->next())

- return false;

- addProperty(propId, CSSValuePair::create(parsedValue1.release(), parsedValue2.release(), CSSValuePair::DropIdenticalValues), important);

- return true;

- }

- case CSSPropertyTabSize:

- // May be specified as a unit-less non-negative integer or length indicating number of space characters.

- validPrimitive = validUnit(value, FInteger | FLength | FNonNeg);

- break;

- case CSSPropertyBorderRadius:

- case CSSPropertyAliasWebkitBorderRadius:

- return parseBorderRadius(unresolvedProperty, important);

- case CSSPropertyOutlineOffset:

- validPrimitive = validUnit(value, FLength);

- break;

- case CSSPropertyTextShadow: // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3

- case CSSPropertyBoxShadow:

- if (id == CSSValueNone)

- validPrimitive = true;

- else

- parsedValue = parseShadow(m_valueList, propId);

- break;

- case CSSPropertyWebkitBoxReflect:

- if (id == CSSValueNone)

- validPrimitive = true;

- else

- parsedValue = parseReflect();

- break;

- case CSSPropertyFontSizeAdjust: // none | <number>

- ASSERT(RuntimeEnabledFeatures::cssFontSizeAdjustEnabled());

- validPrimitive = (id == CSSValueNone) ? true : validUnit(value, FNumber | FNonNeg);

- break;

- case CSSPropertyOpacity:

- case CSSPropertyWebkitBoxFlex:

- validPrimitive = validUnit(value, FNumber);

- break;

- case CSSPropertyWebkitBoxFlexGroup:

- validPrimitive = validUnit(value, FInteger | FNonNeg);

- break;

- case CSSPropertyWebkitBoxOrdinalGroup:

- validPrimitive = validUnit(value, FInteger | FNonNeg) && value->fValue;

- break;

- case CSSPropertyWebkitFilter:

- case CSSPropertyBackdropFilter:

- if (id == CSSValueNone)

- validPrimitive = true;

- else {

- RefPtrWillBeRawPtr<CSSValue> val = parseFilter();

- if (val) {

- addProperty(propId, val, important);

- return true;

- }

- return false;

- }

- break;

- case CSSPropertyFlex: {

- ShorthandScope scope(this, propId);

- if (id == CSSValueNone) {

- addProperty(CSSPropertyFlexGrow, cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Number), important);

- addProperty(CSSPropertyFlexShrink, cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Number), important);

- addProperty(CSSPropertyFlexBasis, cssValuePool().createIdentifierValue(CSSValueAuto), important);

- return true;

- }

- return parseFlex(m_valueList, important);

- }

- case CSSPropertyFlexBasis:

- // FIXME: Support intrinsic dimensions too.

- if (id == CSSValueAuto)

- validPrimitive = true;

- else

- validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);

- break;

- case CSSPropertyFlexGrow:

- case CSSPropertyFlexShrink:

- validPrimitive = validUnit(value, FNumber | FNonNeg);

- break;

- case CSSPropertyOrder:

- validPrimitive = validUnit(value, FInteger);

- break;

- case CSSPropertyTransform:

- if (id == CSSValueNone)

- validPrimitive = true;

- else

- parsedValue = parseTransform(unresolvedProperty == CSSPropertyAliasWebkitTransform);

- break;

- case CSSPropertyTransformOrigin: {

- RefPtrWillBeRawPtr<CSSValueList> list = parseTransformOrigin();

- if (!list)

- return false;

- // These values are added to match gecko serialization.

- if (list->length() == 1)

- list->append(cssValuePool().createValue(50, CSSPrimitiveValue::UnitType::Percentage));

- if (list->length() == 2)

- list->append(cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Pixels));

- addProperty(propId, list.release(), important);

- return true;

- }

- case CSSPropertyTranslate: {

- // translate : [ <length> | <percentage> ] [[ <length> | <percentage> ] <length>? ]?

- // defaults to 0 on all axis, note that the last value CANNOT be a percentage

- ASSERT(RuntimeEnabledFeatures::cssIndependentTransformPropertiesEnabled());

- RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

- if (!validUnit(value, FLength | FPercent))

- return false;

- list->append(createPrimitiveNumericValue(value));

- value = m_valueList->next();

- if (value) {

- if (!validUnit(value, FLength | FPercent))

- return false;

- list->append(createPrimitiveNumericValue(value));

- value = m_valueList->next();

- if (value) {

- if (!validUnit(value, FLength))

- return false;

- list->append(createPrimitiveNumericValue(value));

- value = m_valueList->next();

- }

- parsedValue = list.release();

- break;

- }

- case CSSPropertyRotate: { // rotate : <angle> <number>{3}? defaults to a 0 0 1

- ASSERT(RuntimeEnabledFeatures::cssIndependentTransformPropertiesEnabled());

- RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

- if (!validUnit(value, FAngle))

- return false;

- list->append(createPrimitiveNumericValue(value));

- value = m_valueList->next();

- if (!value) {

- parsedValue = list.release();

- break;

- }

- for (unsigned i = 0; i < 3; i++) { // 3 dimensions of rotation

- if (!value || !validUnit(value, FNumber))

- return false;

- list->append(createPrimitiveNumericValue(value));

- value = m_valueList->next();

- }

- parsedValue = list.release();

- break;

- }

- case CSSPropertyScale: { // scale: <number>{1,3}, default scale for all axis is 1

- ASSERT(RuntimeEnabledFeatures::cssIndependentTransformPropertiesEnabled());

- RefPtrWillBeRawPtr<CSSValueList> scaleList = CSSValueList::createSpaceSeparated();

- for (unsigned i = 0; value && i < 3; i++) { // up to 3 dimensions of scale

- if (!validUnit(value, FNumber))

- return false;

- scaleList->append(createPrimitiveNumericValue(value));

- value = m_valueList->next();

- }

- parsedValue = scaleList.release();

- break;

- }

- case CSSPropertyWebkitPerspectiveOriginX:

- case CSSPropertyWebkitTransformOriginX:

- parsedValue = parseFillPositionX(m_valueList);

- if (parsedValue)

- m_valueList->next();

- break;

- case CSSPropertyWebkitPerspectiveOriginY:

- case CSSPropertyWebkitTransformOriginY:

- parsedValue = parseFillPositionY(m_valueList);

- if (parsedValue)

- m_valueList->next();

- break;

- case CSSPropertyWebkitTransformOriginZ:

- validPrimitive = validUnit(value, FLength);

- break;

- case CSSPropertyPerspective:

- if (id == CSSValueNone) {

- validPrimitive = true;

- } else if (validUnit(value, FLength) && (m_parsedCalculation || value->fValue > 0)) {

- validPrimitive = true;

- } else if (unresolvedProperty == CSSPropertyAliasWebkitPerspective && validUnit(value, FNumber) && value->fValue > 0) {

- value->setUnit(CSSPrimitiveValue::UnitType::Pixels);

- validPrimitive = true;

- } else {

- return false;

- }

- break;

- case CSSPropertyPerspectiveOrigin: {

- RefPtrWillBeRawPtr<CSSValueList> list = parseTransformOrigin();

- if (!list || list->length() == 3)

- return false;

- // This values are added to match gecko serialization.

- if (list->length() == 1)

- list->append(cssValuePool().createValue(50, CSSPrimitiveValue::UnitType::Percentage));

- addProperty(propId, list.release(), important);

- return true;

- }

- case CSSPropertyMotion:

- // <motion-path> && <motion-offset> && <motion-rotation>

- ASSERT(RuntimeEnabledFeatures::cssMotionPathEnabled());

- return parseShorthand(propId, motionShorthand(), important);

- case CSSPropertyMotionPath:

- ASSERT(RuntimeEnabledFeatures::cssMotionPathEnabled());

- if (id == CSSValueNone)

- validPrimitive = true;

- else

- parsedValue = parseMotionPath();

- break;

- case CSSPropertyMotionOffset:

- ASSERT(RuntimeEnabledFeatures::cssMotionPathEnabled());

- validPrimitive = validUnit(value, FLength | FPercent);

- break;

- case CSSPropertyMotionRotation:

- ASSERT(RuntimeEnabledFeatures::cssMotionPathEnabled());

- parsedValue = parseMotionRotation();

- break;

- case CSSPropertyAnimationDelay:

- case CSSPropertyAnimationDirection:

- case CSSPropertyAnimationDuration:

- case CSSPropertyAnimationFillMode:

- case CSSPropertyAnimationName:

- case CSSPropertyAnimationPlayState:

- case CSSPropertyAnimationIterationCount:

- case CSSPropertyAnimationTimingFunction:

- case CSSPropertyTransitionDelay:

- case CSSPropertyTransitionDuration:

- case CSSPropertyTransitionTimingFunction:

- case CSSPropertyTransitionProperty:

- parsedValue = parseAnimationPropertyList(propId, unresolvedProperty == CSSPropertyAliasWebkitAnimationName);

- break;

- case CSSPropertyJustifyContent:

- parsedValue = parseContentDistributionOverflowPosition();

- break;

- case CSSPropertyJustifySelf:

- ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());

- return parseItemPositionOverflowPosition(propId, important);

- case CSSPropertyJustifyItems:

- ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());

- if (parseLegacyPosition(propId, important))

- return true;

- m_valueList->setCurrentIndex(0);

- return parseItemPositionOverflowPosition(propId, important);

- case CSSPropertyGridAutoFlow:

- ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());

- parsedValue = parseGridAutoFlow(*m_valueList);

- break;

- case CSSPropertyGridAutoColumns:

- case CSSPropertyGridAutoRows:

- ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());

- parsedValue = parseGridTrackSize(*m_valueList);

- break;

- case CSSPropertyGridTemplateColumns:

- case CSSPropertyGridTemplateRows:

- ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());

- parsedValue = parseGridTrackList();

- break;

- case CSSPropertyGridColumnEnd:

- case CSSPropertyGridColumnStart:

- case CSSPropertyGridRowEnd:

- case CSSPropertyGridRowStart:

- ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());

- parsedValue = parseGridPosition();

- break;

- case CSSPropertyGridColumn:

- case CSSPropertyGridRow:

- ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());

- return parseGridItemPositionShorthand(propId, important);

- case CSSPropertyGridArea:

- ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());

- return parseGridAreaShorthand(important);

- case CSSPropertyGridTemplateAreas:

- ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());

- parsedValue = parseGridTemplateAreas();

- break;

- case CSSPropertyGridTemplate:

- ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());

- return parseGridTemplateShorthand(important);

- case CSSPropertyGrid:

- ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());

- return parseGridShorthand(important);

- case CSSPropertyWebkitMarginCollapse: {

- ShorthandScope scope(this, CSSPropertyWebkitMarginCollapse);

- if (!parseValue(webkitMarginCollapseShorthand().properties()[0], important))

- return false;

- if (!m_valueList->current()) {

- CSSValue* value = m_parsedProperties.last().value();

- addProperty(webkitMarginCollapseShorthand().properties()[1], value, important);

- return true;

- }

- if (!parseValue(webkitMarginCollapseShorthand().properties()[1], important))

- return false;

- return !m_valueList->current();

- }

- case CSSPropertyWebkitColumnCount:

- parsedValue = parseColumnCount();

- break;

- case CSSPropertyWebkitColumnGap: // normal | <length>

- if (id == CSSValueNormal)

- validPrimitive = true;

- else

- validPrimitive = validUnit(value, FLength | FNonNeg);

- break;

- case CSSPropertyWebkitColumnSpan: // none | all | 1 (will be dropped in the unprefixed property)

- validPrimitive = id == CSSValueAll || id == CSSValueNone || (value->unit() == CSSPrimitiveValue::UnitType::Number && value->fValue == 1);

- break;

- case CSSPropertyWebkitColumnWidth: // auto | <length>

- parsedValue = parseColumnWidth();

- break;

- case CSSPropertyWillChange:

- parsedValue = parseWillChange();

- break;

- // End of CSS3 properties

- // Apple specific properties. These will never be standardized and are purely to

- // support custom WebKit-based Apple applications.

- case CSSPropertyWebkitLineClamp:

- // When specifying number of lines, don't allow 0 as a valid value

- // When specifying either type of unit, require non-negative integers

- validPrimitive = (!id && !isCalculation(value) && validUnit(value, FInteger | FPercent | FNonNeg) && (value->unit() == CSSPrimitiveValue::UnitType::Percentage || value->fValue));

- break;

- case CSSPropertyWebkitFontSizeDelta: // <length>

- validPrimitive = validUnit(value, FLength | FUnitlessQuirk);

- break;

- case CSSPropertyWebkitHighlight:

- if (id == CSSValueNone) {

- validPrimitive = true;

- } else if (value->unit() == CSSPrimitiveValue::UnitType::String) {

- parsedValue = createPrimitiveStringValue(value);

- m_valueList->next();

- }

- break;

- case CSSPropertyWebkitHyphenateCharacter:

- case CSSPropertyWebkitLocale:

- if (id == CSSValueAuto) {

- validPrimitive = true;

- } else if (value->unit() == CSSPrimitiveValue::UnitType::String) {

- parsedValue = createPrimitiveStringValue(value);

- m_valueList->next();

- }

- break;

- // End Apple-specific properties

- case CSSPropertyWebkitAppRegion:

- if (id >= CSSValueDrag && id <= CSSValueNoDrag)

- validPrimitive = true;

- break;

- case CSSPropertyWebkitTapHighlightColor:

- parsedValue = parseColor(m_valueList->current());

- if (parsedValue)

- m_valueList->next();

- break;

- /* shorthand properties */

- case CSSPropertyBackground: {

- // Position must come before color in this array because a plain old "0" is a legal color

- // in quirks mode but it's usually the X coordinate of a position.

- const CSSPropertyID properties[] = { CSSPropertyBackgroundImage, CSSPropertyBackgroundRepeat,

- CSSPropertyBackgroundAttachment, CSSPropertyBackgroundPosition, CSSPropertyBackgroundOrigin,

- CSSPropertyBackgroundClip, CSSPropertyBackgroundColor, CSSPropertyBackgroundSize };

- return parseFillShorthand(propId, properties, WTF_ARRAY_LENGTH(properties), important);

- }

- case CSSPropertyWebkitMask: {

- const CSSPropertyID properties[] = { CSSPropertyWebkitMaskImage, CSSPropertyWebkitMaskRepeat,

- CSSPropertyWebkitMaskPosition, CSSPropertyWebkitMaskOrigin, CSSPropertyWebkitMaskClip, CSSPropertyWebkitMaskSize };

- return parseFillShorthand(propId, properties, WTF_ARRAY_LENGTH(properties), important);

- }

- case CSSPropertyBorder:

- // [ 'border-width' || 'border-style' || <color> ] | inherit

- {

- if (parseShorthand(propId, borderShorthandForParsing(), important)) {

- // The CSS3 Borders and Backgrounds specification says that border also resets border-image. It's as

- // though a value of none was specified for the image.

- addExpandedPropertyForValue(CSSPropertyBorderImage, cssValuePool().createImplicitInitialValue(), important);

- return true;

- }

- return false;

- }

- case CSSPropertyBorderTop:

- // [ 'border-top-width' || 'border-style' || <color> ] | inherit

- return parseShorthand(propId, borderTopShorthand(), important);

- case CSSPropertyBorderRight:

- // [ 'border-right-width' || 'border-style' || <color> ] | inherit

- return parseShorthand(propId, borderRightShorthand(), important);

- case CSSPropertyBorderBottom:

- // [ 'border-bottom-width' || 'border-style' || <color> ] | inherit

- return parseShorthand(propId, borderBottomShorthand(), important);

- case CSSPropertyBorderLeft:

- // [ 'border-left-width' || 'border-style' || <color> ] | inherit

- return parseShorthand(propId, borderLeftShorthand(), important);

- case CSSPropertyWebkitBorderStart:

- return parseShorthand(propId, webkitBorderStartShorthand(), important);

- case CSSPropertyWebkitBorderEnd:

- return parseShorthand(propId, webkitBorderEndShorthand(), important);

- case CSSPropertyWebkitBorderBefore:

- return parseShorthand(propId, webkitBorderBeforeShorthand(), important);

- case CSSPropertyWebkitBorderAfter:

- return parseShorthand(propId, webkitBorderAfterShorthand(), important);

- case CSSPropertyOutline:

- // [ 'outline-color' || 'outline-style' || 'outline-width' ] | inherit

- return parseShorthand(propId, outlineShorthand(), important);

- case CSSPropertyBorderColor:

- // <color>{1,4} | inherit

- return parse4Values(propId, borderColorShorthand().properties(), important);

- case CSSPropertyBorderWidth:

- // <border-width>{1,4} | inherit

- return parse4Values(propId, borderWidthShorthand().properties(), important);

- case CSSPropertyBorderStyle:

- // <border-style>{1,4} | inherit

- return parse4Values(propId, borderStyleShorthand().properties(), important);

- case CSSPropertyMargin:

- // <margin-width>{1,4} | inherit

- return parse4Values(propId, marginShorthand().properties(), important);

- case CSSPropertyPadding:

- // <padding-width>{1,4} | inherit

- return parse4Values(propId, paddingShorthand().properties(), important);

- case CSSPropertyFlexFlow:

- return parseShorthand(propId, flexFlowShorthand(), important);

- case CSSPropertyFont:

- // [ [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]?

- if (id >= CSSValueCaption && id <= CSSValueStatusBar)

- return parseSystemFont(important);

- return parseFont(important);

- case CSSPropertyListStyle:

- return parseShorthand(propId, listStyleShorthand(), important);

- case CSSPropertyWebkitColumns:

- return parseColumnsShorthand(important);

- case CSSPropertyWebkitColumnRule:

- return parseShorthand(propId, webkitColumnRuleShorthand(), important);

- case CSSPropertyWebkitTextStroke:

- return parseShorthand(propId, webkitTextStrokeShorthand(), important);

- case CSSPropertyAnimation:

- return parseAnimationShorthand(unresolvedProperty == CSSPropertyAliasWebkitAnimation, important);

- case CSSPropertyTransition:

- return parseTransitionShorthand(important);

- case CSSPropertyInvalid:

- return false;

- case CSSPropertyPage:

- parsedValue = parsePage();

- break;

- // CSS Text Layout Module Level 3: Vertical writing support

- case CSSPropertyWebkitTextEmphasis:

- return parseShorthand(propId, webkitTextEmphasisShorthand(), important);

- case CSSPropertyWebkitTextEmphasisStyle:

- parsedValue = parseTextEmphasisStyle();

- break;

- case CSSPropertyWebkitTextOrientation:

- // FIXME: For now just support sideways, sideways-right, upright and vertical-right.

- if (id == CSSValueSideways || id == CSSValueSidewaysRight || id == CSSValueVerticalRight || id == CSSValueUpright)

- validPrimitive = true;

- break;

- case CSSPropertyWebkitFontFeatureSettings:

- if (id == CSSValueNormal)

- validPrimitive = true;

- else

- parsedValue = parseFontFeatureSettings();

- break;

- case CSSPropertyFontVariantLigatures:

- if (id == CSSValueNormal)

- validPrimitive = true;

- else

- return parseFontVariantLigatures(important);

- break;

- case CSSPropertyWebkitClipPath:

- if (id == CSSValueNone) {

- validPrimitive = true;

- } else if (value->m_unit == CSSParserValue::Function) {

- parsedValue = parseBasicShape();

- } else if (value->unit() == CSSPrimitiveValue::UnitType::URI) {

- parsedValue = CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::UnitType::URI);

- addProperty(propId, parsedValue.release(), important);

- return true;

- }

- break;

- case CSSPropertyShapeOutside:

- if (id == CSSValueNone)

- validPrimitive = true;

- else

- parsedValue = parseShapeProperty(propId);

- break;

- case CSSPropertyShapeMargin:

- validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);

- break;

- case CSSPropertyShapeImageThreshold:

- validPrimitive = validUnit(value, FNumber);

- break;

- case CSSPropertyTouchAction:

- parsedValue = parseTouchAction();

- break;

- case CSSPropertyAlignContent:

- parsedValue = parseContentDistributionOverflowPosition();

- break;

- case CSSPropertyAlignSelf:

- ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());

- return parseItemPositionOverflowPosition(propId, important);

- case CSSPropertyAlignItems:

- ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());

- return parseItemPositionOverflowPosition(propId, important);

- // Properties below are validated inside parseViewportProperty, because we

- // check for parser state. We need to invalidate if someone adds them outside

- // a @viewport rule.

- case CSSPropertyMaxZoom:

- case CSSPropertyMinZoom:

- case CSSPropertyOrientation:

- case CSSPropertyUserZoom:

- validPrimitive = false;

- break;

- case CSSPropertyScrollSnapPointsX:

- case CSSPropertyScrollSnapPointsY:

- parsedValue = parseScrollSnapPoints();

- break;

- case CSSPropertyScrollSnapCoordinate:

- parsedValue = parseScrollSnapCoordinate();

- break;

- case CSSPropertyScrollSnapDestination:

- parsedValue = parsePosition(m_valueList);

- break;

- default:

- return parseSVGValue(propId, important);

- }

- if (validPrimitive) {

- parsedValue = parseValidPrimitive(id, value);

- m_valueList->next();

- }

- ASSERT(!m_parsedCalculation);

- if (parsedValue) {

- if (!m_valueList->current() || inShorthand()) {

- addProperty(propId, parsedValue.release(), important);

- return true;

- }

- return false;

-void CSSPropertyParser::addFillValue(RefPtrWillBeRawPtr<CSSValue>& lval, PassRefPtrWillBeRawPtr<CSSValue> rval)

- if (lval) {

- if (lval->isBaseValueList())

- toCSSValueList(lval.get())->append(rval);

- else {

- PassRefPtrWillBeRawPtr<CSSValue> oldlVal(lval.release());

- PassRefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

- list->append(oldlVal);

- list->append(rval);

- lval = list;

- }

- else

- lval = rval;

-static bool parseBackgroundClip(CSSParserValue* parserValue, RefPtrWillBeRawPtr<CSSValue>& cssValue)

- if (parserValue->id == CSSValueBorderBox || parserValue->id == CSSValuePaddingBox

- || parserValue->id == CSSValueContentBox || parserValue->id == CSSValueWebkitText) {

- cssValue = cssValuePool().createIdentifierValue(parserValue->id);

- return true;

- }

- return false;

-const int cMaxFillProperties = 9;

-bool CSSPropertyParser::parseFillShorthand(CSSPropertyID propId, const CSSPropertyID* properties, int numProperties, bool important)

- ASSERT(numProperties <= cMaxFillProperties);

- if (numProperties > cMaxFillProperties)

- return false;

- ShorthandScope scope(this, propId);

- bool parsedProperty[cMaxFillProperties] = { false };

- RefPtrWillBeRawPtr<CSSValue> values[cMaxFillProperties];

-#if ENABLE(OILPAN)

- // Zero initialize the array of raw pointers.

- memset(&values, 0, sizeof(values));

-#endif

- RefPtrWillBeRawPtr<CSSValue> clipValue = nullptr;

- RefPtrWillBeRawPtr<CSSValue> positionYValue = nullptr;

- RefPtrWillBeRawPtr<CSSValue> repeatYValue = nullptr;

- bool foundClip = false;

- int i;

- bool foundPositionCSSProperty = false;

- while (m_valueList->current()) {

- CSSParserValue* val = m_valueList->current();

- if (isComma(val)) {

- // We hit the end. Fill in all remaining values with the initial value.

- m_valueList->next();

- for (i = 0; i < numProperties; ++i) {

- if (properties[i] == CSSPropertyBackgroundColor && parsedProperty[i])

- // Color is not allowed except as the last item in a list for backgrounds.

- // Reject the entire property.

- return false;

- if (!parsedProperty[i] && properties[i] != CSSPropertyBackgroundColor) {

- addFillValue(values[i], cssValuePool().createImplicitInitialValue());

- if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)

- addFillValue(positionYValue, cssValuePool().createImplicitInitialValue());

- if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)

- addFillValue(repeatYValue, cssValuePool().createImplicitInitialValue());

- if ((properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) && !parsedProperty[i]) {

- // If background-origin wasn't present, then reset background-clip also.

- addFillValue(clipValue, cssValuePool().createImplicitInitialValue());

- }

- parsedProperty[i] = false;

- }

- if (!m_valueList->current())

- break;

- }

- bool sizeCSSPropertyExpected = false;

- if (isForwardSlashOperator(val) && foundPositionCSSProperty) {

- sizeCSSPropertyExpected = true;

- m_valueList->next();

- }

- foundPositionCSSProperty = false;

- bool found = false;

- for (i = 0; !found && i < numProperties; ++i) {

- if (sizeCSSPropertyExpected && (properties[i] != CSSPropertyBackgroundSize && properties[i] != CSSPropertyWebkitMaskSize))

- continue;

- if (!sizeCSSPropertyExpected && (properties[i] == CSSPropertyBackgroundSize || properties[i] == CSSPropertyWebkitMaskSize))

- continue;

- if (!parsedProperty[i]) {

- RefPtrWillBeRawPtr<CSSValue> val1 = nullptr;

- RefPtrWillBeRawPtr<CSSValue> val2 = nullptr;

- CSSPropertyID propId1, propId2;

- CSSParserValue* parserValue = m_valueList->current();

- // parseFillProperty() may modify m_implicitShorthand, so we MUST reset it

- // before EACH return below.

- if (parserValue && parseFillProperty(properties[i], propId1, propId2, val1, val2)) {

- parsedProperty[i] = found = true;

- addFillValue(values[i], val1.release());

- if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)

- addFillValue(positionYValue, val2.release());

- if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)

- addFillValue(repeatYValue, val2.release());

- if (properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) {

- // Reparse the value as a clip, and see if we succeed.

- if (parseBackgroundClip(parserValue, val1))

- addFillValue(clipValue, val1.release()); // The property parsed successfully.

- else

- addFillValue(clipValue, cssValuePool().createImplicitInitialValue()); // Some value was used for origin that is not supported by clip. Just reset clip instead.

- }

- if (properties[i] == CSSPropertyBackgroundClip || properties[i] == CSSPropertyWebkitMaskClip) {

- // Update clipValue

- addFillValue(clipValue, val1.release());

- foundClip = true;

- }

- if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)

- foundPositionCSSProperty = true;

- }

- // if we didn't find at least one match, this is an

- // invalid shorthand and we have to ignore it

- if (!found) {

- m_implicitShorthand = false;

- return false;

- }

- // Now add all of the properties we found.

- for (i = 0; i < numProperties; i++) {

- // Fill in any remaining properties with the initial value.