| Index: third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp
|
| diff --git a/third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp b/third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp
|
| index 6ca22bca6a57d001061fb51cb99bb9db7024c6d1..78df51a0478257de9ecae00317dba30e65677e7b 100644
|
| --- a/third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp
|
| +++ b/third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp
|
| @@ -42,7 +42,7 @@
|
| namespace blink {
|
|
|
| CSSPropertyParser::CSSPropertyParser(const CSSParserTokenRange& range,
|
| - const CSSParserContext& context, WillBeHeapVector<CSSProperty, 256>& parsedProperties)
|
| + const CSSParserContext& context, HeapVector<CSSProperty, 256>& parsedProperties)
|
| : m_range(range)
|
| , m_context(context)
|
| , m_parsedProperties(parsedProperties)
|
| @@ -66,7 +66,7 @@ static bool hasInvalidNumericValues(const CSSParserTokenRange& range)
|
|
|
| bool CSSPropertyParser::parseValue(CSSPropertyID unresolvedProperty, bool important,
|
| const CSSParserTokenRange& range, const CSSParserContext& context,
|
| - WillBeHeapVector<CSSProperty, 256>& parsedProperties, StyleRule::Type ruleType)
|
| + HeapVector<CSSProperty, 256>& parsedProperties, StyleRule::Type ruleType)
|
| {
|
| if (hasInvalidNumericValues(range))
|
| return false;
|
| @@ -114,7 +114,7 @@ bool CSSPropertyParser::parseValueStart(CSSPropertyID unresolvedProperty, bool i
|
| if (parseShorthand(unresolvedProperty, important))
|
| return true;
|
| } else {
|
| - if (RefPtrWillBeRawPtr<CSSValue> parsedValue = parseSingleValue(unresolvedProperty)) {
|
| + if (RawPtr<CSSValue> parsedValue = parseSingleValue(unresolvedProperty)) {
|
| if (!m_range.atEnd())
|
| return false;
|
| addProperty(propertyId, parsedValue.release(), important);
|
| @@ -124,7 +124,7 @@ bool CSSPropertyParser::parseValueStart(CSSPropertyID unresolvedProperty, bool i
|
|
|
| if (RuntimeEnabledFeatures::cssVariablesEnabled() && CSSVariableParser::containsValidVariableReferences(originalRange)) {
|
| // We don't expand the shorthand here because crazypants.
|
| - RefPtrWillBeRawPtr<CSSVariableReferenceValue> variable = CSSVariableReferenceValue::create(CSSVariableData::create(originalRange));
|
| + RawPtr<CSSVariableReferenceValue> variable = CSSVariableReferenceValue::create(CSSVariableData::create(originalRange));
|
| addProperty(propertyId, variable.release(), important);
|
| return true;
|
| }
|
| @@ -248,7 +248,7 @@ bool CSSPropertyParser::consumeCSSWideKeyword(CSSPropertyID unresolvedProperty,
|
| if (!rangeCopy.atEnd())
|
| return false;
|
|
|
| - RefPtrWillBeRawPtr<CSSValue> value = nullptr;
|
| + RawPtr<CSSValue> value = nullptr;
|
| if (id == CSSValueInitial)
|
| value = cssValuePool().createExplicitInitialValue();
|
| else if (id == CSSValueInherit)
|
| @@ -273,7 +273,7 @@ static bool consumeCommaIncludingWhitespace(CSSParserTokenRange& valueList)
|
| return true;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange& range)
|
| +static RawPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().type() != IdentToken)
|
| return nullptr;
|
| @@ -286,28 +286,28 @@ template<CSSValueID head, CSSValueID... tail> inline bool identMatches(CSSValueI
|
| return id == head || identMatches<tail...>(id);
|
| }
|
|
|
| -template<CSSValueID... names> PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange& range)
|
| +template<CSSValueID... names> RawPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().type() != IdentToken || !identMatches<names...>(range.peek().id()))
|
| return nullptr;
|
| return cssValuePool().createIdentifierValue(range.consumeIncludingWhitespace().id());
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeIdentRange(CSSParserTokenRange& range, CSSValueID lower, CSSValueID upper)
|
| +static RawPtr<CSSPrimitiveValue> consumeIdentRange(CSSParserTokenRange& range, CSSValueID lower, CSSValueID upper)
|
| {
|
| if (range.peek().id() < lower || range.peek().id() > upper)
|
| return nullptr;
|
| return consumeIdent(range);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSCustomIdentValue> consumeCustomIdent(CSSParserTokenRange& range)
|
| +static RawPtr<CSSCustomIdentValue> consumeCustomIdent(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().type() != IdentToken)
|
| return nullptr;
|
| return CSSCustomIdentValue::create(range.consumeIncludingWhitespace().value());
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSStringValue> consumeString(CSSParserTokenRange& range)
|
| +static RawPtr<CSSStringValue> consumeString(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().type() != StringToken)
|
| return nullptr;
|
| @@ -360,14 +360,14 @@ public:
|
| }
|
|
|
| const CSSCalcValue* value() const { return m_calcValue.get(); }
|
| - PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeValue()
|
| + RawPtr<CSSPrimitiveValue> consumeValue()
|
| {
|
| if (!m_calcValue)
|
| return nullptr;
|
| m_sourceRange = m_range;
|
| return CSSPrimitiveValue::create(m_calcValue.release());
|
| }
|
| - PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeNumber()
|
| + RawPtr<CSSPrimitiveValue> consumeNumber()
|
| {
|
| if (!m_calcValue)
|
| return nullptr;
|
| @@ -388,10 +388,10 @@ public:
|
| private:
|
| CSSParserTokenRange& m_sourceRange;
|
| CSSParserTokenRange m_range;
|
| - RefPtrWillBeMember<CSSCalcValue> m_calcValue;
|
| + Member<CSSCalcValue> m_calcValue;
|
| };
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeInteger(CSSParserTokenRange& range, double minimumValue = -std::numeric_limits<double>::max())
|
| +static RawPtr<CSSPrimitiveValue> consumeInteger(CSSParserTokenRange& range, double minimumValue = -std::numeric_limits<double>::max())
|
| {
|
| const CSSParserToken& token = range.peek();
|
| if (token.type() == NumberToken) {
|
| @@ -411,7 +411,7 @@ static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeInteger(CSSParserTokenRa
|
| return nullptr;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumePositiveInteger(CSSParserTokenRange& range)
|
| +static RawPtr<CSSPrimitiveValue> consumePositiveInteger(CSSParserTokenRange& range)
|
| {
|
| return consumeInteger(range, 1);
|
| }
|
| @@ -427,7 +427,7 @@ static bool consumeNumberRaw(CSSParserTokenRange& range, double& result)
|
| }
|
|
|
| // TODO(timloh): Work out if this can just call consumeNumberRaw
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeNumber(CSSParserTokenRange& range, ValueRange valueRange)
|
| +static RawPtr<CSSPrimitiveValue> consumeNumber(CSSParserTokenRange& range, ValueRange valueRange)
|
| {
|
| const CSSParserToken& token = range.peek();
|
| if (token.type() == NumberToken) {
|
| @@ -454,7 +454,7 @@ inline bool shouldAcceptUnitlessValues(double fValue, CSSParserMode cssParserMod
|
| || (cssParserMode == HTMLQuirksMode && (unitless == UnitlessQuirk::Allow));
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeLength(CSSParserTokenRange& range, CSSParserMode cssParserMode, ValueRange valueRange, UnitlessQuirk unitless = UnitlessQuirk::Forbid)
|
| +static RawPtr<CSSPrimitiveValue> consumeLength(CSSParserTokenRange& range, CSSParserMode cssParserMode, ValueRange valueRange, UnitlessQuirk unitless = UnitlessQuirk::Forbid)
|
| {
|
| const CSSParserToken& token = range.peek();
|
| if (token.type() == DimensionToken) {
|
| @@ -503,7 +503,7 @@ static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeLength(CSSParserTokenRan
|
| return nullptr;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumePercent(CSSParserTokenRange& range, ValueRange valueRange)
|
| +static RawPtr<CSSPrimitiveValue> consumePercent(CSSParserTokenRange& range, ValueRange valueRange)
|
| {
|
| const CSSParserToken& token = range.peek();
|
| if (token.type() == PercentageToken) {
|
| @@ -519,7 +519,7 @@ static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumePercent(CSSParserTokenRa
|
| return nullptr;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeLengthOrPercent(CSSParserTokenRange& range, CSSParserMode cssParserMode, ValueRange valueRange, UnitlessQuirk unitless = UnitlessQuirk::Forbid)
|
| +static RawPtr<CSSPrimitiveValue> consumeLengthOrPercent(CSSParserTokenRange& range, CSSParserMode cssParserMode, ValueRange valueRange, UnitlessQuirk unitless = UnitlessQuirk::Forbid)
|
| {
|
| const CSSParserToken& token = range.peek();
|
| if (token.type() == DimensionToken || token.type() == NumberToken)
|
| @@ -534,7 +534,7 @@ static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeLengthOrPercent(CSSParse
|
| return nullptr;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeAngle(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSPrimitiveValue> consumeAngle(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| const CSSParserToken& token = range.peek();
|
| if (token.type() == DimensionToken) {
|
| @@ -561,7 +561,7 @@ static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeAngle(CSSParserTokenRang
|
| return nullptr;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeTime(CSSParserTokenRange& range, ValueRange valueRange)
|
| +static RawPtr<CSSPrimitiveValue> consumeTime(CSSParserTokenRange& range, ValueRange valueRange)
|
| {
|
| const CSSParserToken& token = range.peek();
|
| if (token.type() == DimensionToken) {
|
| @@ -593,7 +593,7 @@ static bool parseRGBParameters(CSSParserTokenRange& range, RGBA32& result, bool
|
| {
|
| ASSERT(range.peek().functionId() == CSSValueRgb || range.peek().functionId() == CSSValueRgba);
|
| CSSParserTokenRange args = consumeFunction(range);
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> colorParameter = consumeInteger(args);
|
| + RawPtr<CSSPrimitiveValue> colorParameter = consumeInteger(args);
|
| if (!colorParameter)
|
| colorParameter = consumePercent(args, ValueRangeAll);
|
| if (!colorParameter)
|
| @@ -629,7 +629,7 @@ static bool parseHSLParameters(CSSParserTokenRange& range, RGBA32& result, bool
|
| {
|
| ASSERT(range.peek().functionId() == CSSValueHsl || range.peek().functionId() == CSSValueHsla);
|
| CSSParserTokenRange args = consumeFunction(range);
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> hslValue = consumeNumber(args, ValueRangeAll);
|
| + RawPtr<CSSPrimitiveValue> hslValue = consumeNumber(args, ValueRangeAll);
|
| if (!hslValue)
|
| return false;
|
| double colorArray[3];
|
| @@ -694,7 +694,7 @@ static bool parseColorFunction(CSSParserTokenRange& range, RGBA32& result)
|
| return true;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeColor(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool acceptQuirkyColors = false)
|
| +static RawPtr<CSSValue> consumeColor(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool acceptQuirkyColors = false)
|
| {
|
| CSSValueID id = range.peek().id();
|
| if (CSSPropertyParser::isColorKeyword(id)) {
|
| @@ -708,7 +708,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeColor(CSSParserTokenRange& range,
|
| return cssValuePool().createColorValue(color);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumePositionComponent(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
|
| +static RawPtr<CSSPrimitiveValue> consumePositionComponent(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
|
| {
|
| if (range.peek().type() == IdentToken)
|
| return consumeIdent<CSSValueLeft, CSSValueTop, CSSValueBottom, CSSValueRight, CSSValueCenter>(range);
|
| @@ -725,7 +725,7 @@ static bool isVerticalPositionKeywordOnly(const CSSPrimitiveValue& value)
|
| return value.isValueID() && (value.getValueID() == CSSValueTop || value.getValueID() == CSSValueBottom);
|
| }
|
|
|
| -static void positionFromOneValue(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> value, RefPtrWillBeRawPtr<CSSValue>& resultX, RefPtrWillBeRawPtr<CSSValue>& resultY)
|
| +static void positionFromOneValue(RawPtr<CSSPrimitiveValue> value, RawPtr<CSSValue>& resultX, RawPtr<CSSValue>& resultY)
|
| {
|
| bool valueAppliesToYAxisOnly = isVerticalPositionKeywordOnly(*value);
|
| resultX = value;
|
| @@ -734,8 +734,8 @@ static void positionFromOneValue(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> value
|
| swap(resultX, resultY);
|
| }
|
|
|
| -static bool positionFromTwoValues(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> value1, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> value2,
|
| - RefPtrWillBeRawPtr<CSSValue>& resultX, RefPtrWillBeRawPtr<CSSValue>& resultY)
|
| +static bool positionFromTwoValues(RawPtr<CSSPrimitiveValue> value1, RawPtr<CSSPrimitiveValue> value2,
|
| + RawPtr<CSSValue>& resultX, RawPtr<CSSValue>& resultY)
|
| {
|
| bool mustOrderAsXY = isHorizontalPositionKeywordOnly(*value1) || isVerticalPositionKeywordOnly(*value2)
|
| || !value1->isValueID() || !value2->isValueID();
|
| @@ -749,7 +749,7 @@ static bool positionFromTwoValues(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valu
|
| return true;
|
| }
|
|
|
| -static bool positionFromThreeOrFourValues(CSSPrimitiveValue** values, RefPtrWillBeRawPtr<CSSValue>& resultX, RefPtrWillBeRawPtr<CSSValue>& resultY)
|
| +static bool positionFromThreeOrFourValues(CSSPrimitiveValue** values, RawPtr<CSSValue>& resultX, RawPtr<CSSValue>& resultY)
|
| {
|
| CSSPrimitiveValue* center = nullptr;
|
| for (int i = 0; values[i]; i++) {
|
| @@ -765,7 +765,7 @@ static bool positionFromThreeOrFourValues(CSSPrimitiveValue** values, RefPtrWill
|
| continue;
|
| }
|
|
|
| - RefPtrWillBeRawPtr<CSSValue> result = nullptr;
|
| + RawPtr<CSSValue> result = nullptr;
|
| if (values[i + 1] && !values[i + 1]->isValueID()) {
|
| result = CSSValuePair::create(currentValue, values[++i], CSSValuePair::KeepIdenticalValues);
|
| } else {
|
| @@ -799,23 +799,23 @@ static bool positionFromThreeOrFourValues(CSSPrimitiveValue** values, RefPtrWill
|
| }
|
|
|
| // This may consume from the range upon failure since no caller needs the stricter behaviour.
|
| -static bool consumePosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless, RefPtrWillBeRawPtr<CSSValue>& resultX, RefPtrWillBeRawPtr<CSSValue>& resultY)
|
| +static bool consumePosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless, RawPtr<CSSValue>& resultX, RawPtr<CSSValue>& resultY)
|
| {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> value1 = consumePositionComponent(range, cssParserMode, unitless);
|
| + RawPtr<CSSPrimitiveValue> value1 = consumePositionComponent(range, cssParserMode, unitless);
|
| if (!value1)
|
| return false;
|
|
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> value2 = consumePositionComponent(range, cssParserMode, unitless);
|
| + RawPtr<CSSPrimitiveValue> value2 = consumePositionComponent(range, cssParserMode, unitless);
|
| if (!value2) {
|
| positionFromOneValue(value1.release(), resultX, resultY);
|
| return true;
|
| }
|
|
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> value3 = consumePositionComponent(range, cssParserMode, unitless);
|
| + RawPtr<CSSPrimitiveValue> value3 = consumePositionComponent(range, cssParserMode, unitless);
|
| if (!value3)
|
| return positionFromTwoValues(value1.release(), value2.release(), resultX, resultY);
|
|
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> value4 = consumePositionComponent(range, cssParserMode, unitless);
|
| + RawPtr<CSSPrimitiveValue> value4 = consumePositionComponent(range, cssParserMode, unitless);
|
| CSSPrimitiveValue* values[5];
|
| values[0] = value1.get();
|
| values[1] = value2.get();
|
| @@ -825,21 +825,21 @@ static bool consumePosition(CSSParserTokenRange& range, CSSParserMode cssParserM
|
| return positionFromThreeOrFourValues(values, resultX, resultY);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumePosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
|
| +static RawPtr<CSSValue> consumePosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValue> resultX = nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> resultY = nullptr;
|
| + RawPtr<CSSValue> resultX = nullptr;
|
| + RawPtr<CSSValue> resultY = nullptr;
|
| if (consumePosition(range, cssParserMode, unitless, resultX, resultY))
|
| return CSSValuePair::create(resultX.release(), resultY.release(), CSSValuePair::KeepIdenticalValues);
|
| return nullptr;
|
| }
|
|
|
| -static bool consumeOneOrTwoValuedPosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless, RefPtrWillBeRawPtr<CSSValue>& resultX, RefPtrWillBeRawPtr<CSSValue>& resultY)
|
| +static bool consumeOneOrTwoValuedPosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless, RawPtr<CSSValue>& resultX, RawPtr<CSSValue>& resultY)
|
| {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> value1 = consumePositionComponent(range, cssParserMode, unitless);
|
| + RawPtr<CSSPrimitiveValue> value1 = consumePositionComponent(range, cssParserMode, unitless);
|
| if (!value1)
|
| return false;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> value2 = consumePositionComponent(range, cssParserMode, unitless);
|
| + RawPtr<CSSPrimitiveValue> value2 = consumePositionComponent(range, cssParserMode, unitless);
|
| if (!value2) {
|
| positionFromOneValue(value1.release(), resultX, resultY);
|
| return true;
|
| @@ -847,15 +847,15 @@ static bool consumeOneOrTwoValuedPosition(CSSParserTokenRange& range, CSSParserM
|
| return positionFromTwoValues(value1.release(), value2.release(), resultX, resultY);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValueList> consumeTransformOrigin(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
|
| +static RawPtr<CSSValueList> consumeTransformOrigin(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValue> resultX = nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> resultY = nullptr;
|
| + RawPtr<CSSValue> resultX = nullptr;
|
| + RawPtr<CSSValue> resultY = nullptr;
|
| if (consumeOneOrTwoValuedPosition(range, cssParserMode, unitless, resultX, resultY)) {
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| list->append(resultX.release());
|
| list->append(resultY.release());
|
| - RefPtrWillBeRawPtr<CSSValue> resultZ = consumeLength(range, cssParserMode, ValueRangeAll);
|
| + RawPtr<CSSValue> resultZ = consumeLength(range, cssParserMode, ValueRangeAll);
|
| if (!resultZ)
|
| resultZ = cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Pixels);
|
| list->append(resultZ.release());
|
| @@ -870,12 +870,12 @@ static inline bool isCSSWideKeyword(const CSSValueID& id)
|
| }
|
|
|
| // Methods for consuming non-shorthand properties starts here.
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeWillChange(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeWillChange(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().id() == CSSValueAuto)
|
| return consumeIdent(range);
|
|
|
| - RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
|
| + RawPtr<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) {
|
| @@ -918,7 +918,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeWillChange(CSSParserTokenRange& r
|
| return values.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSFontFeatureValue> consumeFontFeatureTag(CSSParserTokenRange& range)
|
| +static RawPtr<CSSFontFeatureValue> consumeFontFeatureTag(CSSParserTokenRange& range)
|
| {
|
| // Feature tag name consists of 4-letter characters.
|
| static const unsigned tagNameLength = 4;
|
| @@ -949,13 +949,13 @@ static PassRefPtrWillBeRawPtr<CSSFontFeatureValue> consumeFontFeatureTag(CSSPars
|
| return CSSFontFeatureValue::create(tag, tagValue);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeFontFeatureSettings(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeFontFeatureSettings(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().id() == CSSValueNormal)
|
| return consumeIdent(range);
|
| - RefPtrWillBeRawPtr<CSSValueList> settings = CSSValueList::createCommaSeparated();
|
| + RawPtr<CSSValueList> settings = CSSValueList::createCommaSeparated();
|
| do {
|
| - RefPtrWillBeRawPtr<CSSFontFeatureValue> fontFeatureValue = consumeFontFeatureTag(range);
|
| + RawPtr<CSSFontFeatureValue> fontFeatureValue = consumeFontFeatureTag(range);
|
| if (!fontFeatureValue)
|
| return nullptr;
|
| settings->append(fontFeatureValue);
|
| @@ -963,20 +963,20 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeFontFeatureSettings(CSSParserToke
|
| return settings.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumePage(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumePage(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().id() == CSSValueAuto)
|
| return consumeIdent(range);
|
| return consumeCustomIdent(range);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeQuotes(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeQuotes(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
| - RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
|
| while (!range.atEnd()) {
|
| - RefPtrWillBeRawPtr<CSSStringValue> parsedValue = consumeString(range);
|
| + RawPtr<CSSStringValue> parsedValue = consumeString(range);
|
| if (!parsedValue)
|
| return nullptr;
|
| values->append(parsedValue.release());
|
| @@ -986,18 +986,18 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeQuotes(CSSParserTokenRange& range
|
| return nullptr;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeWebkitHighlight(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeWebkitHighlight(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
| return consumeString(range);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeFontVariantLigatures(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeFontVariantLigatures(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().id() == CSSValueNormal)
|
| return consumeIdent(range);
|
| - RefPtrWillBeRawPtr<CSSValueList> ligatureValues = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> ligatureValues = CSSValueList::createSpaceSeparated();
|
| bool sawCommonLigaturesValue = false;
|
| bool sawDiscretionaryLigaturesValue = false;
|
| bool sawHistoricalLigaturesValue = false;
|
| @@ -1038,14 +1038,14 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeFontVariantLigatures(CSSParserTok
|
| return ligatureValues.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeFontVariant(CSSParserTokenRange& range)
|
| +static RawPtr<CSSPrimitiveValue> consumeFontVariant(CSSParserTokenRange& range)
|
| {
|
| return consumeIdent<CSSValueNormal, CSSValueSmallCaps>(range);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeFontVariantList(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeFontVariantList(CSSParserTokenRange& range)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
|
| + RawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
|
| do {
|
| if (range.peek().id() == CSSValueAll) {
|
| // FIXME: CSSPropertyParser::parseFontVariant() implements
|
| @@ -1056,7 +1056,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeFontVariantList(CSSParserTokenRan
|
| return nullptr;
|
| return consumeIdent(range);
|
| }
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> fontVariant = consumeFontVariant(range);
|
| + RawPtr<CSSPrimitiveValue> fontVariant = consumeFontVariant(range);
|
| if (fontVariant)
|
| values->append(fontVariant.release());
|
| } while (consumeCommaIncludingWhitespace(range));
|
| @@ -1067,7 +1067,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeFontVariantList(CSSParserTokenRan
|
| return nullptr;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeFontWeight(CSSParserTokenRange& range)
|
| +static RawPtr<CSSPrimitiveValue> consumeFontWeight(CSSParserTokenRange& range)
|
| {
|
| const CSSParserToken& token = range.peek();
|
| if (token.id() >= CSSValueNormal && token.id() <= CSSValueLighter)
|
| @@ -1098,7 +1098,7 @@ static String concatenateFamilyName(CSSParserTokenRange& range)
|
| return builder.toString();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeFamilyName(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeFamilyName(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().type() == StringToken)
|
| return cssValuePool().createFontFamilyValue(range.consumeIncludingWhitespace().value());
|
| @@ -1110,16 +1110,16 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeFamilyName(CSSParserTokenRange& r
|
| return cssValuePool().createFontFamilyValue(familyName);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeGenericFamily(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeGenericFamily(CSSParserTokenRange& range)
|
| {
|
| return consumeIdentRange(range, CSSValueSerif, CSSValueWebkitBody);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValueList> consumeFontFamily(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValueList> consumeFontFamily(CSSParserTokenRange& range)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| do {
|
| - RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
|
| + RawPtr<CSSValue> parsedValue = nullptr;
|
| if ((parsedValue = consumeGenericFamily(range))) {
|
| list->append(parsedValue);
|
| } else if ((parsedValue = consumeFamilyName(range))) {
|
| @@ -1131,7 +1131,7 @@ static PassRefPtrWillBeRawPtr<CSSValueList> consumeFontFamily(CSSParserTokenRang
|
| return list.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeSpacing(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeSpacing(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| if (range.peek().id() == CSSValueNormal)
|
| return consumeIdent(range);
|
| @@ -1139,38 +1139,38 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeSpacing(CSSParserTokenRange& rang
|
| return consumeLength(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeTabSize(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeTabSize(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue = consumeInteger(range, 0);
|
| + RawPtr<CSSPrimitiveValue> parsedValue = consumeInteger(range, 0);
|
| if (parsedValue)
|
| return parsedValue;
|
| return consumeLength(range, cssParserMode, ValueRangeNonNegative);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeFontSize(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless = UnitlessQuirk::Forbid)
|
| +static RawPtr<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 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeLineHeight(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSPrimitiveValue> consumeLineHeight(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| if (range.peek().id() == CSSValueNormal)
|
| return consumeIdent(range);
|
|
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> lineHeight = consumeNumber(range, ValueRangeNonNegative);
|
| + RawPtr<CSSPrimitiveValue> lineHeight = consumeNumber(range, ValueRangeNonNegative);
|
| if (lineHeight)
|
| return lineHeight;
|
| return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValueList> consumeRotation(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValueList> consumeRotation(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| ASSERT(RuntimeEnabledFeatures::cssIndependentTransformPropertiesEnabled());
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
|
|
| - RefPtrWillBeRawPtr<CSSValue> rotation = consumeAngle(range, cssParserMode);
|
| + RawPtr<CSSValue> rotation = consumeAngle(range, cssParserMode);
|
| if (!rotation)
|
| return nullptr;
|
| list->append(rotation.release());
|
| @@ -1179,7 +1179,7 @@ static PassRefPtrWillBeRawPtr<CSSValueList> consumeRotation(CSSParserTokenRange&
|
| return list.release();
|
|
|
| for (unsigned i = 0; i < 3; i++) { // 3 dimensions of rotation
|
| - RefPtrWillBeRawPtr<CSSValue> dimension = consumeNumber(range, ValueRangeAll);
|
| + RawPtr<CSSValue> dimension = consumeNumber(range, ValueRangeAll);
|
| if (!dimension)
|
| return nullptr;
|
| list->append(dimension.release());
|
| @@ -1188,14 +1188,14 @@ static PassRefPtrWillBeRawPtr<CSSValueList> consumeRotation(CSSParserTokenRange&
|
| return list.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValueList> consumeScale(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValueList> consumeScale(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| ASSERT(RuntimeEnabledFeatures::cssIndependentTransformPropertiesEnabled());
|
|
|
| - RefPtrWillBeRawPtr<CSSValue> scale = consumeNumber(range, ValueRangeAll);
|
| + RawPtr<CSSValue> scale = consumeNumber(range, ValueRangeAll);
|
| if (!scale)
|
| return nullptr;
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| list->append(scale.release());
|
| if ((scale = consumeNumber(range, ValueRangeAll))) {
|
| list->append(scale.release());
|
| @@ -1206,13 +1206,13 @@ static PassRefPtrWillBeRawPtr<CSSValueList> consumeScale(CSSParserTokenRange& ra
|
| return list.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValueList> consumeTranslate(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValueList> consumeTranslate(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| ASSERT(RuntimeEnabledFeatures::cssIndependentTransformPropertiesEnabled());
|
| - RefPtrWillBeRawPtr<CSSValue> translate = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll);
|
| + RawPtr<CSSValue> translate = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll);
|
| if (!translate)
|
| return nullptr;
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| list->append(translate.release());
|
| if ((translate = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll))) {
|
| list->append(translate.release());
|
| @@ -1223,18 +1223,18 @@ static PassRefPtrWillBeRawPtr<CSSValueList> consumeTranslate(CSSParserTokenRange
|
| return list.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeCounter(CSSParserTokenRange& range, CSSParserMode cssParserMode, int defaultValue)
|
| +static RawPtr<CSSValue> consumeCounter(CSSParserTokenRange& range, CSSParserMode cssParserMode, int defaultValue)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
|
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| do {
|
| - RefPtrWillBeRawPtr<CSSCustomIdentValue> counterName = consumeCustomIdent(range);
|
| + RawPtr<CSSCustomIdentValue> counterName = consumeCustomIdent(range);
|
| if (!counterName)
|
| return nullptr;
|
| int i = defaultValue;
|
| - if (RefPtrWillBeRawPtr<CSSPrimitiveValue> counterValue = consumeInteger(range))
|
| + if (RawPtr<CSSPrimitiveValue> counterValue = consumeInteger(range))
|
| i = clampTo<int>(counterValue->getDoubleValue());
|
| list->append(CSSValuePair::create(counterName.release(),
|
| cssValuePool().createValue(i, CSSPrimitiveValue::UnitType::Integer),
|
| @@ -1243,30 +1243,30 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeCounter(CSSParserTokenRange& rang
|
| return list.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumePageSize(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumePageSize(CSSParserTokenRange& range)
|
| {
|
| return consumeIdent<CSSValueA3, CSSValueA4, CSSValueA5, CSSValueB4, CSSValueB5, CSSValueLedger, CSSValueLegal, CSSValueLetter>(range);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValueList> consumeSize(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValueList> consumeSize(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
|
|
|
| if (range.peek().id() == CSSValueAuto) {
|
| result->append(consumeIdent(range));
|
| return result.release();
|
| }
|
|
|
| - if (RefPtrWillBeRawPtr<CSSValue> width = consumeLength(range, cssParserMode, ValueRangeNonNegative)) {
|
| - RefPtrWillBeRawPtr<CSSValue> height = consumeLength(range, cssParserMode, ValueRangeNonNegative);
|
| + if (RawPtr<CSSValue> width = consumeLength(range, cssParserMode, ValueRangeNonNegative)) {
|
| + RawPtr<CSSValue> height = consumeLength(range, cssParserMode, ValueRangeNonNegative);
|
| result->append(width.release());
|
| if (height)
|
| result->append(height.release());
|
| return result.release();
|
| }
|
|
|
| - RefPtrWillBeRawPtr<CSSValue> pageSize = consumePageSize(range);
|
| - RefPtrWillBeRawPtr<CSSValue> orientation = consumeIdent<CSSValuePortrait, CSSValueLandscape>(range);
|
| + RawPtr<CSSValue> pageSize = consumePageSize(range);
|
| + RawPtr<CSSValue> orientation = consumeIdent<CSSValuePortrait, CSSValueLandscape>(range);
|
| if (!pageSize)
|
| pageSize = consumePageSize(range);
|
|
|
| @@ -1279,11 +1279,11 @@ static PassRefPtrWillBeRawPtr<CSSValueList> consumeSize(CSSParserTokenRange& ran
|
| return result.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeTextIndent(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeTextIndent(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| // [ <length> | <percentage> ] && hanging? && each-line?
|
| // Keywords only allowed when css3Text is enabled.
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
|
|
| bool hasLengthOrPercentage = false;
|
| bool hasEachLine = false;
|
| @@ -1291,7 +1291,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeTextIndent(CSSParserTokenRange& r
|
|
|
| do {
|
| if (!hasLengthOrPercentage) {
|
| - if (RefPtrWillBeRawPtr<CSSValue> textIndent = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow)) {
|
| + if (RawPtr<CSSValue> textIndent = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow)) {
|
| list->append(textIndent.release());
|
| hasLengthOrPercentage = true;
|
| continue;
|
| @@ -1347,35 +1347,35 @@ static bool validWidthOrHeightKeyword(CSSValueID id, const CSSParserContext& con
|
| return false;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeMaxWidthOrHeight(CSSParserTokenRange& range, const CSSParserContext& context, UnitlessQuirk unitless = UnitlessQuirk::Forbid)
|
| +static RawPtr<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 PassRefPtrWillBeRawPtr<CSSValue> consumeWidthOrHeight(CSSParserTokenRange& range, const CSSParserContext& context, UnitlessQuirk unitless = UnitlessQuirk::Forbid)
|
| +static RawPtr<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 PassRefPtrWillBeRawPtr<CSSValue> consumeMarginWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
|
| +static RawPtr<CSSValue> consumeMarginWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
|
| {
|
| if (range.peek().id() == CSSValueAuto)
|
| return consumeIdent(range);
|
| return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, unitless);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeClipComponent(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSPrimitiveValue> consumeClipComponent(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| if (range.peek().id() == CSSValueAuto)
|
| return consumeIdent(range);
|
| return consumeLength(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeClip(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeClip(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| if (range.peek().id() == CSSValueAuto)
|
| return consumeIdent(range);
|
| @@ -1385,23 +1385,23 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeClip(CSSParserTokenRange& range,
|
|
|
| CSSParserTokenRange args = consumeFunction(range);
|
| // rect(t, r, b, l) || rect(t r b l)
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> top = consumeClipComponent(args, cssParserMode);
|
| + RawPtr<CSSPrimitiveValue> top = consumeClipComponent(args, cssParserMode);
|
| if (!top)
|
| return nullptr;
|
| bool needsComma = consumeCommaIncludingWhitespace(args);
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> right = consumeClipComponent(args, cssParserMode);
|
| + RawPtr<CSSPrimitiveValue> right = consumeClipComponent(args, cssParserMode);
|
| if (!right || (needsComma && !consumeCommaIncludingWhitespace(args)))
|
| return nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> bottom = consumeClipComponent(args, cssParserMode);
|
| + RawPtr<CSSPrimitiveValue> bottom = consumeClipComponent(args, cssParserMode);
|
| if (!bottom || (needsComma && !consumeCommaIncludingWhitespace(args)))
|
| return nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> left = consumeClipComponent(args, cssParserMode);
|
| + RawPtr<CSSPrimitiveValue> left = consumeClipComponent(args, cssParserMode);
|
| if (!left || !args.atEnd())
|
| return nullptr;
|
| return CSSQuadValue::create(top.release(), right.release(), bottom.release(), left.release(), CSSQuadValue::SerializeAsRect);
|
| }
|
|
|
| -static bool consumePan(CSSParserTokenRange& range, RefPtrWillBeRawPtr<CSSValue>& panX, RefPtrWillBeRawPtr<CSSValue>& panY)
|
| +static bool consumePan(CSSParserTokenRange& range, RawPtr<CSSValue>& panX, RawPtr<CSSValue>& panY)
|
| {
|
| CSSValueID id = range.peek().id();
|
| if ((id == CSSValuePanX || id == CSSValuePanRight || id == CSSValuePanLeft) && !panX) {
|
| @@ -1418,17 +1418,17 @@ static bool consumePan(CSSParserTokenRange& range, RefPtrWillBeRawPtr<CSSValue>&
|
| return true;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeTouchAction(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeTouchAction(CSSParserTokenRange& range)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| CSSValueID id = range.peek().id();
|
| if (id == CSSValueAuto || id == CSSValueNone || id == CSSValueManipulation) {
|
| list->append(consumeIdent(range));
|
| return list.release();
|
| }
|
|
|
| - RefPtrWillBeRawPtr<CSSValue> panX = nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> panY = nullptr;
|
| + RawPtr<CSSValue> panX = nullptr;
|
| + RawPtr<CSSValue> panY = nullptr;
|
| if (!consumePan(range, panX, panY))
|
| return nullptr;
|
| if (!range.atEnd() && !consumePan(range, panX, panY))
|
| @@ -1441,59 +1441,59 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeTouchAction(CSSParserTokenRange&
|
| return list.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeLineClamp(CSSParserTokenRange& range)
|
| +static RawPtr<CSSPrimitiveValue> consumeLineClamp(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().type() != PercentageToken && range.peek().type() != NumberToken)
|
| return nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> clampValue = consumePercent(range, ValueRangeNonNegative);
|
| + RawPtr<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 PassRefPtrWillBeRawPtr<CSSValue> consumeLocale(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeLocale(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().id() == CSSValueAuto)
|
| return consumeIdent(range);
|
| return consumeString(range);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeColumnWidth(CSSParserTokenRange& range)
|
| +static RawPtr<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.
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> columnWidth = consumeLength(range, HTMLStandardMode, ValueRangeNonNegative);
|
| + RawPtr<CSSPrimitiveValue> columnWidth = consumeLength(range, HTMLStandardMode, ValueRangeNonNegative);
|
| if (!columnWidth || (!columnWidth->isCalculated() && columnWidth->getDoubleValue() == 0))
|
| return nullptr;
|
| return columnWidth.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeColumnCount(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeColumnCount(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().id() == CSSValueAuto)
|
| return consumeIdent(range);
|
| return consumePositiveInteger(range);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeColumnGap(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeColumnGap(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| if (range.peek().id() == CSSValueNormal)
|
| return consumeIdent(range);
|
| return consumeLength(range, cssParserMode, ValueRangeNonNegative);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeColumnSpan(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeColumnSpan(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| return consumeIdent<CSSValueAll, CSSValueNone>(range);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeZoom(CSSParserTokenRange& range, const CSSParserContext& context)
|
| +static RawPtr<CSSValue> consumeZoom(CSSParserTokenRange& range, const CSSParserContext& context)
|
| {
|
| const CSSParserToken& token = range.peek();
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> zoom = nullptr;
|
| + RawPtr<CSSPrimitiveValue> zoom = nullptr;
|
| if (token.type() == IdentToken) {
|
| zoom = consumeIdent<CSSValueNormal, CSSValueReset, CSSValueDocument>(range);
|
| } else {
|
| @@ -1509,14 +1509,14 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeZoom(CSSParserTokenRange& range,
|
| return zoom.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeAnimationIterationCount(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeAnimationIterationCount(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().id() == CSSValueInfinite)
|
| return consumeIdent(range);
|
| return consumeNumber(range, ValueRangeNonNegative);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeAnimationName(CSSParserTokenRange& range, const CSSParserContext& context, bool allowQuotedName)
|
| +static RawPtr<CSSValue> consumeAnimationName(CSSParserTokenRange& range, const CSSParserContext& context, bool allowQuotedName)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
| @@ -1535,7 +1535,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeAnimationName(CSSParserTokenRange
|
| return consumeCustomIdent(range);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeTransitionProperty(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeTransitionProperty(CSSParserTokenRange& range)
|
| {
|
| const CSSParserToken& token = range.peek();
|
| if (token.type() != IdentToken)
|
| @@ -1554,13 +1554,13 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeTransitionProperty(CSSParserToken
|
| return consumeCustomIdent(range);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeSteps(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeSteps(CSSParserTokenRange& range)
|
| {
|
| ASSERT(range.peek().functionId() == CSSValueSteps);
|
| CSSParserTokenRange rangeCopy = range;
|
| CSSParserTokenRange args = consumeFunction(rangeCopy);
|
|
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> steps = consumePositiveInteger(args);
|
| + RawPtr<CSSPrimitiveValue> steps = consumePositiveInteger(args);
|
| if (!steps)
|
| return nullptr;
|
|
|
| @@ -1590,7 +1590,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeSteps(CSSParserTokenRange& range)
|
| return CSSStepsTimingFunctionValue::create(steps->getIntValue(), position);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeCubicBezier(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeCubicBezier(CSSParserTokenRange& range)
|
| {
|
| ASSERT(range.peek().functionId() == CSSValueCubicBezier);
|
| CSSParserTokenRange rangeCopy = range;
|
| @@ -1614,7 +1614,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeCubicBezier(CSSParserTokenRange&
|
| return nullptr;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeAnimationTimingFunction(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeAnimationTimingFunction(CSSParserTokenRange& range)
|
| {
|
| CSSValueID id = range.peek().id();
|
| if (id == CSSValueEase || id == CSSValueLinear || id == CSSValueEaseIn
|
| @@ -1630,7 +1630,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeAnimationTimingFunction(CSSParser
|
| return nullptr;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeAnimationValue(CSSPropertyID property, CSSParserTokenRange& range, const CSSParserContext& context, bool useLegacyParsing)
|
| +static RawPtr<CSSValue> consumeAnimationValue(CSSPropertyID property, CSSParserTokenRange& range, const CSSParserContext& context, bool useLegacyParsing)
|
| {
|
| switch (property) {
|
| case CSSPropertyAnimationDelay:
|
| @@ -1672,11 +1672,11 @@ static bool isValidAnimationPropertyList(CSSPropertyID property, const CSSValueL
|
| return true;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValueList> consumeAnimationPropertyList(CSSPropertyID property, CSSParserTokenRange& range, const CSSParserContext& context, bool useLegacyParsing)
|
| +static RawPtr<CSSValueList> consumeAnimationPropertyList(CSSPropertyID property, CSSParserTokenRange& range, const CSSParserContext& context, bool useLegacyParsing)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| do {
|
| - RefPtrWillBeRawPtr<CSSValue> value = consumeAnimationValue(property, range, context, useLegacyParsing);
|
| + RawPtr<CSSValue> value = consumeAnimationValue(property, range, context, useLegacyParsing);
|
| if (!value)
|
| return nullptr;
|
| list->append(value.release());
|
| @@ -1690,7 +1690,7 @@ static PassRefPtrWillBeRawPtr<CSSValueList> consumeAnimationPropertyList(CSSProp
|
| bool CSSPropertyParser::consumeAnimationShorthand(const StylePropertyShorthand& shorthand, bool useLegacyParsing, bool important)
|
| {
|
| const unsigned longhandCount = shorthand.length();
|
| - RefPtrWillBeRawPtr<CSSValueList> longhands[8];
|
| + RawPtr<CSSValueList> longhands[8];
|
| ASSERT(longhandCount <= 8);
|
| for (size_t i = 0; i < longhandCount; ++i)
|
| longhands[i] = CSSValueList::createCommaSeparated();
|
| @@ -1703,7 +1703,7 @@ bool CSSPropertyParser::consumeAnimationShorthand(const StylePropertyShorthand&
|
| if (parsedLonghand[i])
|
| continue;
|
|
|
| - if (RefPtrWillBeRawPtr<CSSValue> value = consumeAnimationValue(shorthand.properties()[i], m_range, m_context, useLegacyParsing)) {
|
| + if (RawPtr<CSSValue> value = consumeAnimationValue(shorthand.properties()[i], m_range, m_context, useLegacyParsing)) {
|
| parsedLonghand[i] = true;
|
| foundProperty = true;
|
| longhands[i]->append(value.release());
|
| @@ -1733,7 +1733,7 @@ bool CSSPropertyParser::consumeAnimationShorthand(const StylePropertyShorthand&
|
| return m_range.atEnd();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeWidowsOrOrphans(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeWidowsOrOrphans(CSSParserTokenRange& range)
|
| {
|
| // Support for auto is non-standard and for backwards compatibility.
|
| if (range.peek().id() == CSSValueAuto)
|
| @@ -1741,17 +1741,17 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeWidowsOrOrphans(CSSParserTokenRan
|
| return consumePositiveInteger(range);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeZIndex(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeZIndex(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().id() == CSSValueAuto)
|
| return consumeIdent(range);
|
| return consumeInteger(range);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSShadowValue> parseSingleShadow(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool allowInset, bool allowSpread)
|
| +static RawPtr<CSSShadowValue> parseSingleShadow(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool allowInset, bool allowSpread)
|
| {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> style = nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> color = nullptr;
|
| + RawPtr<CSSPrimitiveValue> style = nullptr;
|
| + RawPtr<CSSValue> color = nullptr;
|
|
|
| if (range.atEnd())
|
| return nullptr;
|
| @@ -1762,16 +1762,16 @@ static PassRefPtrWillBeRawPtr<CSSShadowValue> parseSingleShadow(CSSParserTokenRa
|
| }
|
| color = consumeColor(range, cssParserMode);
|
|
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalOffset = consumeLength(range, cssParserMode, ValueRangeAll);
|
| + RawPtr<CSSPrimitiveValue> horizontalOffset = consumeLength(range, cssParserMode, ValueRangeAll);
|
| if (!horizontalOffset)
|
| return nullptr;
|
|
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> verticalOffset = consumeLength(range, cssParserMode, ValueRangeAll);
|
| + RawPtr<CSSPrimitiveValue> verticalOffset = consumeLength(range, cssParserMode, ValueRangeAll);
|
| if (!verticalOffset)
|
| return nullptr;
|
|
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> blurRadius = consumeLength(range, cssParserMode, ValueRangeAll);
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> spreadDistance = nullptr;
|
| + RawPtr<CSSPrimitiveValue> blurRadius = consumeLength(range, cssParserMode, ValueRangeAll);
|
| + RawPtr<CSSPrimitiveValue> spreadDistance = nullptr;
|
| if (blurRadius) {
|
| // Blur radius must be non-negative.
|
| if (blurRadius->getDoubleValue() < 0)
|
| @@ -1793,14 +1793,14 @@ static PassRefPtrWillBeRawPtr<CSSShadowValue> parseSingleShadow(CSSParserTokenRa
|
| spreadDistance.release(), style.release(), color.release());
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeShadow(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool isBoxShadowProperty)
|
| +static RawPtr<CSSValue> consumeShadow(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool isBoxShadowProperty)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
|
|
| - RefPtrWillBeRawPtr<CSSValueList> shadowValueList = CSSValueList::createCommaSeparated();
|
| + RawPtr<CSSValueList> shadowValueList = CSSValueList::createCommaSeparated();
|
| do {
|
| - if (RefPtrWillBeRawPtr<CSSShadowValue> shadowValue = parseSingleShadow(range, cssParserMode, isBoxShadowProperty, isBoxShadowProperty))
|
| + if (RawPtr<CSSShadowValue> shadowValue = parseSingleShadow(range, cssParserMode, isBoxShadowProperty, isBoxShadowProperty))
|
| shadowValueList->append(shadowValue.release());
|
| else
|
| return nullptr;
|
| @@ -1808,14 +1808,14 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeShadow(CSSParserTokenRange& range
|
| return shadowValueList;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSFunctionValue> consumeFilterFunction(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSFunctionValue> consumeFilterFunction(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| CSSValueID filterType = range.peek().functionId();
|
| if (filterType < CSSValueInvert || filterType > CSSValueDropShadow)
|
| return nullptr;
|
| CSSParserTokenRange args = consumeFunction(range);
|
| - RefPtrWillBeRawPtr<CSSFunctionValue> filterValue = CSSFunctionValue::create(filterType);
|
| - RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
|
| + RawPtr<CSSFunctionValue> filterValue = CSSFunctionValue::create(filterType);
|
| + RawPtr<CSSValue> parsedValue = nullptr;
|
|
|
| if (filterType == CSSValueDropShadow) {
|
| parsedValue = parseSingleShadow(args, cssParserMode, false, false);
|
| @@ -1850,15 +1850,15 @@ static PassRefPtrWillBeRawPtr<CSSFunctionValue> consumeFilterFunction(CSSParserT
|
| return filterValue.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeFilter(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeFilter(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
|
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| do {
|
| String url = consumeUrl(range);
|
| - RefPtrWillBeRawPtr<CSSFunctionValue> filterValue = nullptr;
|
| + RawPtr<CSSFunctionValue> filterValue = nullptr;
|
| if (!url.isNull()) {
|
| filterValue = CSSFunctionValue::create(CSSValueUrl);
|
| filterValue->append(CSSSVGDocumentValue::create(url));
|
| @@ -1872,14 +1872,14 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeFilter(CSSParserTokenRange& range
|
| return list.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeTextDecorationLine(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeTextDecorationLine(CSSParserTokenRange& range)
|
| {
|
| CSSValueID id = range.peek().id();
|
| if (id == CSSValueNone)
|
| return consumeIdent(range);
|
|
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> ident = nullptr;
|
| + RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSPrimitiveValue> ident = nullptr;
|
| while ((ident = consumeIdent<CSSValueBlink, CSSValueUnderline, CSSValueOverline, CSSValueLineThrough>(range))) {
|
| if (list->hasValue(ident.get()))
|
| return nullptr;
|
| @@ -1892,18 +1892,18 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeTextDecorationLine(CSSParserToken
|
| }
|
|
|
| // none | strict | [ layout || style || paint ]
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeContain(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeContain(CSSParserTokenRange& range)
|
| {
|
| CSSValueID id = range.peek().id();
|
| if (id == CSSValueNone)
|
| return consumeIdent(range);
|
|
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| if (id == CSSValueStrict) {
|
| list->append(consumeIdent(range));
|
| return list.release();
|
| }
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> ident = nullptr;
|
| + RawPtr<CSSPrimitiveValue> ident = nullptr;
|
| while ((ident = consumeIdent<CSSValuePaint, CSSValueLayout, CSSValueStyle>(range))) {
|
| if (list->hasValue(ident.get()))
|
| return nullptr;
|
| @@ -1915,7 +1915,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeContain(CSSParserTokenRange& rang
|
| return list.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumePath(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumePath(CSSParserTokenRange& range)
|
| {
|
| // FIXME: Add support for <url>, <basic-shape>, <geometry-box>.
|
| if (range.peek().functionId() != CSSValuePath)
|
| @@ -1938,7 +1938,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumePath(CSSParserTokenRange& range)
|
| return CSSPathValue::create(byteStream.release());
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumePathOrNone(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumePathOrNone(CSSParserTokenRange& range)
|
| {
|
| CSSValueID id = range.peek().id();
|
| if (id == CSSValueNone)
|
| @@ -1947,17 +1947,17 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumePathOrNone(CSSParserTokenRange& r
|
| return consumePath(range);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeMotionRotation(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeMotionRotation(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValue> angle = consumeAngle(range, cssParserMode);
|
| - RefPtrWillBeRawPtr<CSSValue> keyword = consumeIdent<CSSValueAuto, CSSValueReverse>(range);
|
| + RawPtr<CSSValue> angle = consumeAngle(range, cssParserMode);
|
| + RawPtr<CSSValue> keyword = consumeIdent<CSSValueAuto, CSSValueReverse>(range);
|
| if (!angle && !keyword)
|
| return nullptr;
|
|
|
| if (!angle)
|
| angle = consumeAngle(range, cssParserMode);
|
|
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| if (keyword)
|
| list->append(keyword.release());
|
| if (angle)
|
| @@ -1965,21 +1965,21 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeMotionRotation(CSSParserTokenRang
|
| return list.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeTextEmphasisStyle(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeTextEmphasisStyle(CSSParserTokenRange& range)
|
| {
|
| CSSValueID id = range.peek().id();
|
| if (id == CSSValueNone)
|
| return consumeIdent(range);
|
|
|
| - if (RefPtrWillBeRawPtr<CSSValue> textEmphasisStyle = consumeString(range))
|
| + if (RawPtr<CSSValue> textEmphasisStyle = consumeString(range))
|
| return textEmphasisStyle.release();
|
|
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> fill = consumeIdent<CSSValueFilled, CSSValueOpen>(range);
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> shape = consumeIdent<CSSValueDot, CSSValueCircle, CSSValueDoubleCircle, CSSValueTriangle, CSSValueSesame>(range);
|
| + RawPtr<CSSPrimitiveValue> fill = consumeIdent<CSSValueFilled, CSSValueOpen>(range);
|
| + RawPtr<CSSPrimitiveValue> shape = consumeIdent<CSSValueDot, CSSValueCircle, CSSValueDoubleCircle, CSSValueTriangle, CSSValueSesame>(range);
|
| if (!fill)
|
| fill = consumeIdent<CSSValueFilled, CSSValueOpen>(range);
|
| if (fill && shape) {
|
| - RefPtrWillBeRawPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
|
| parsedValues->append(fill.release());
|
| parsedValues->append(shape.release());
|
| return parsedValues.release();
|
| @@ -1991,7 +1991,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeTextEmphasisStyle(CSSParserTokenR
|
| return nullptr;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeOutlineColor(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeOutlineColor(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| // Outline color has "invert" as additional keyword.
|
| // Also, we want to allow the special focus color even in HTML Standard parsing mode.
|
| @@ -2000,7 +2000,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeOutlineColor(CSSParserTokenRange&
|
| return consumeColor(range, cssParserMode);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeLineWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
|
| +static RawPtr<CSSPrimitiveValue> consumeLineWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
|
| {
|
| CSSValueID id = range.peek().id();
|
| if (id == CSSValueThin || id == CSSValueMedium || id == CSSValueThick)
|
| @@ -2008,25 +2008,25 @@ static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeLineWidth(CSSParserToken
|
| return consumeLength(range, cssParserMode, ValueRangeNonNegative, unitless);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeBorderWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
|
| +static RawPtr<CSSPrimitiveValue> consumeBorderWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
|
| {
|
| return consumeLineWidth(range, cssParserMode, unitless);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeTextStrokeWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSPrimitiveValue> consumeTextStrokeWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| return consumeLineWidth(range, cssParserMode, UnitlessQuirk::Forbid);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeColumnRuleWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSPrimitiveValue> consumeColumnRuleWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| return consumeLineWidth(range, cssParserMode, UnitlessQuirk::Forbid);
|
| }
|
|
|
| -static bool consumeTranslate3d(CSSParserTokenRange& args, CSSParserMode cssParserMode, RefPtrWillBeRawPtr<CSSFunctionValue>& transformValue)
|
| +static bool consumeTranslate3d(CSSParserTokenRange& args, CSSParserMode cssParserMode, RawPtr<CSSFunctionValue>& transformValue)
|
| {
|
| unsigned numberOfArguments = 2;
|
| - RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
|
| + RawPtr<CSSValue> parsedValue = nullptr;
|
| do {
|
| parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
|
| if (!parsedValue)
|
| @@ -2042,10 +2042,10 @@ static bool consumeTranslate3d(CSSParserTokenRange& args, CSSParserMode cssParse
|
| return true;
|
| }
|
|
|
| -static bool consumeNumbers(CSSParserTokenRange& args, RefPtrWillBeRawPtr<CSSFunctionValue>& transformValue, unsigned numberOfArguments)
|
| +static bool consumeNumbers(CSSParserTokenRange& args, RawPtr<CSSFunctionValue>& transformValue, unsigned numberOfArguments)
|
| {
|
| do {
|
| - RefPtrWillBeRawPtr<CSSValue> parsedValue = consumeNumber(args, ValueRangeAll);
|
| + RawPtr<CSSValue> parsedValue = consumeNumber(args, ValueRangeAll);
|
| if (!parsedValue)
|
| return false;
|
| transformValue->append(parsedValue);
|
| @@ -2055,9 +2055,9 @@ static bool consumeNumbers(CSSParserTokenRange& args, RefPtrWillBeRawPtr<CSSFunc
|
| return true;
|
| }
|
|
|
| -static bool consumePerspective(CSSParserTokenRange& args, CSSParserMode cssParserMode, RefPtrWillBeRawPtr<CSSFunctionValue>& transformValue, bool useLegacyParsing)
|
| +static bool consumePerspective(CSSParserTokenRange& args, CSSParserMode cssParserMode, RawPtr<CSSFunctionValue>& transformValue, bool useLegacyParsing)
|
| {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue = consumeLength(args, cssParserMode, ValueRangeNonNegative);
|
| + RawPtr<CSSPrimitiveValue> parsedValue = consumeLength(args, cssParserMode, ValueRangeNonNegative);
|
| if (!parsedValue && useLegacyParsing) {
|
| double perspective;
|
| if (!consumeNumberRaw(args, perspective) || perspective < 0)
|
| @@ -2070,7 +2070,7 @@ static bool consumePerspective(CSSParserTokenRange& args, CSSParserMode cssParse
|
| return true;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeTransformValue(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool useLegacyParsing)
|
| +static RawPtr<CSSValue> consumeTransformValue(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool useLegacyParsing)
|
| {
|
| CSSValueID functionId = range.peek().functionId();
|
| if (functionId == CSSValueInvalid)
|
| @@ -2078,8 +2078,8 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeTransformValue(CSSParserTokenRang
|
| CSSParserTokenRange args = consumeFunction(range);
|
| if (args.atEnd())
|
| return nullptr;
|
| - RefPtrWillBeRawPtr<CSSFunctionValue> transformValue = CSSFunctionValue::create(functionId);
|
| - RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
|
| + RawPtr<CSSFunctionValue> transformValue = CSSFunctionValue::create(functionId);
|
| + RawPtr<CSSValue> parsedValue = nullptr;
|
| switch (functionId) {
|
| case CSSValueRotate:
|
| case CSSValueRotateX:
|
| @@ -2154,14 +2154,14 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeTransformValue(CSSParserTokenRang
|
| return transformValue.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeTransform(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool useLegacyParsing)
|
| +static RawPtr<CSSValue> consumeTransform(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool useLegacyParsing)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
|
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| do {
|
| - RefPtrWillBeRawPtr<CSSValue> parsedTransformValue = consumeTransformValue(range, cssParserMode, useLegacyParsing);
|
| + RawPtr<CSSValue> parsedTransformValue = consumeTransformValue(range, cssParserMode, useLegacyParsing);
|
| if (!parsedTransformValue)
|
| return nullptr;
|
| list->append(parsedTransformValue.release());
|
| @@ -2171,7 +2171,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeTransform(CSSParserTokenRange& ra
|
| }
|
|
|
| template <CSSValueID start, CSSValueID end>
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumePositionLonghand(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumePositionLonghand(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| if (range.peek().type() == IdentToken) {
|
| CSSValueID id = range.peek().id();
|
| @@ -2190,29 +2190,29 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumePositionLonghand(CSSParserTokenRa
|
| return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumePositionX(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumePositionX(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| return consumePositionLonghand<CSSValueLeft, CSSValueRight>(range, cssParserMode);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumePositionY(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumePositionY(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| return consumePositionLonghand<CSSValueTop, CSSValueBottom>(range, cssParserMode);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumePaint(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumePaint(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
| String url = consumeUrl(range);
|
| if (!url.isNull()) {
|
| - RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
|
| + RawPtr<CSSValue> parsedValue = nullptr;
|
| if (range.peek().id() == CSSValueNone)
|
| parsedValue = consumeIdent(range);
|
| else
|
| parsedValue = consumeColor(range, cssParserMode);
|
| if (parsedValue) {
|
| - RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
|
| values->append(CSSURIValue::create(url));
|
| values->append(parsedValue);
|
| return values.release();
|
| @@ -2222,15 +2222,15 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumePaint(CSSParserTokenRange& range,
|
| return consumeColor(range, cssParserMode);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumePaintOrder(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumePaintOrder(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().id() == CSSValueNormal)
|
| return consumeIdent(range);
|
|
|
| Vector<CSSValueID, 3> paintTypeList;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> fill = nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> stroke = nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> markers = nullptr;
|
| + RawPtr<CSSPrimitiveValue> fill = nullptr;
|
| + RawPtr<CSSPrimitiveValue> stroke = nullptr;
|
| + RawPtr<CSSPrimitiveValue> markers = nullptr;
|
| do {
|
| CSSValueID id = range.peek().id();
|
| if (id == CSSValueFill && !fill)
|
| @@ -2248,7 +2248,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumePaintOrder(CSSParserTokenRange& r
|
| // pop a last list items from CSSValueList without bigger cost, we create the
|
| // list after parsing.
|
| CSSValueID firstPaintOrderType = paintTypeList.at(0);
|
| - RefPtrWillBeRawPtr<CSSValueList> paintOrderList = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> paintOrderList = CSSValueList::createSpaceSeparated();
|
| switch (firstPaintOrderType) {
|
| case CSSValueFill:
|
| case CSSValueStroke:
|
| @@ -2272,7 +2272,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumePaintOrder(CSSParserTokenRange& r
|
| return paintOrderList.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeNoneOrURI(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeNoneOrURI(CSSParserTokenRange& range)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
| @@ -2283,7 +2283,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeNoneOrURI(CSSParserTokenRange& ra
|
| return CSSURIValue::create(url);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeFlexBasis(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeFlexBasis(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| // FIXME: Support intrinsic dimensions too.
|
| if (range.peek().id() == CSSValueAuto)
|
| @@ -2291,15 +2291,15 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeFlexBasis(CSSParserTokenRange& ra
|
| return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeStrokeDasharray(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeStrokeDasharray(CSSParserTokenRange& range)
|
| {
|
| CSSValueID id = range.peek().id();
|
| if (id == CSSValueNone)
|
| return consumeIdent(range);
|
|
|
| - RefPtrWillBeRawPtr<CSSValueList> dashes = CSSValueList::createCommaSeparated();
|
| + RawPtr<CSSValueList> dashes = CSSValueList::createCommaSeparated();
|
| do {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> dash = consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
|
| + RawPtr<CSSPrimitiveValue> dash = consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
|
| if (!dash || (consumeCommaIncludingWhitespace(range) && range.atEnd()))
|
| return nullptr;
|
| dashes->append(dash.release());
|
| @@ -2307,7 +2307,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeStrokeDasharray(CSSParserTokenRan
|
| return dashes.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeBaselineShift(CSSParserTokenRange& range)
|
| +static RawPtr<CSSPrimitiveValue> consumeBaselineShift(CSSParserTokenRange& range)
|
| {
|
| CSSValueID id = range.peek().id();
|
| if (id == CSSValueBaseline || id == CSSValueSub || id == CSSValueSuper)
|
| @@ -2315,17 +2315,17 @@ static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeBaselineShift(CSSParserT
|
| return consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeAll);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeImageSet(CSSParserTokenRange& range, const CSSParserContext& context)
|
| +static RawPtr<CSSValue> consumeImageSet(CSSParserTokenRange& range, const CSSParserContext& context)
|
| {
|
| CSSParserTokenRange rangeCopy = range;
|
| CSSParserTokenRange args = consumeFunction(rangeCopy);
|
| - RefPtrWillBeRawPtr<CSSImageSetValue> imageSet = CSSImageSetValue::create();
|
| + RawPtr<CSSImageSetValue> imageSet = CSSImageSetValue::create();
|
| do {
|
| AtomicString urlValue(consumeUrl(args));
|
| if (urlValue.isNull())
|
| return nullptr;
|
|
|
| - RefPtrWillBeRawPtr<CSSValue> image = CSSPropertyParser::createCSSImageValueWithReferrer(urlValue, context);
|
| + RawPtr<CSSValue> image = CSSPropertyParser::createCSSImageValueWithReferrer(urlValue, context);
|
| imageSet->append(image);
|
|
|
| const CSSParserToken& token = args.consumeIncludingWhitespace();
|
| @@ -2345,11 +2345,11 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeImageSet(CSSParserTokenRange& ran
|
| return imageSet.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeCursor(CSSParserTokenRange& range, const CSSParserContext& context, bool inQuirksMode)
|
| +static RawPtr<CSSValue> consumeCursor(CSSParserTokenRange& range, const CSSParserContext& context, bool inQuirksMode)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValueList> list = nullptr;
|
| + RawPtr<CSSValueList> list = nullptr;
|
| while (true) {
|
| - RefPtrWillBeRawPtr<CSSValue> image = nullptr;
|
| + RawPtr<CSSValue> image = nullptr;
|
| AtomicString uri(consumeUrl(range));
|
| if (!uri.isNull()) {
|
| image = CSSPropertyParser::createCSSImageValueWithReferrer(uri, context);
|
| @@ -2387,7 +2387,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeCursor(CSSParserTokenRange& range
|
| else if (id == CSSValueWebkitZoomOut)
|
| context.useCounter()->count(UseCounter::PrefixedCursorZoomOut);
|
| }
|
| - RefPtrWillBeRawPtr<CSSValue> cursorType = nullptr;
|
| + RawPtr<CSSValue> cursorType = nullptr;
|
| if (id == CSSValueHand) {
|
| if (!inQuirksMode) // Non-standard behavior
|
| return nullptr;
|
| @@ -2406,7 +2406,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeCursor(CSSParserTokenRange& range
|
| }
|
|
|
| // This should go away once we drop support for -webkit-gradient
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeDeprecatedGradientPoint(CSSParserTokenRange& args, bool horizontal)
|
| +static RawPtr<CSSPrimitiveValue> consumeDeprecatedGradientPoint(CSSParserTokenRange& args, bool horizontal)
|
| {
|
| if (args.peek().type() == IdentToken) {
|
| if ((horizontal && consumeIdent<CSSValueLeft>(args)) || (!horizontal && consumeIdent<CSSValueTop>(args)))
|
| @@ -2417,14 +2417,14 @@ static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeDeprecatedGradientPoint(
|
| return cssValuePool().createValue(50., CSSPrimitiveValue::UnitType::Percentage);
|
| return nullptr;
|
| }
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> result = consumePercent(args, ValueRangeAll);
|
| + RawPtr<CSSPrimitiveValue> result = consumePercent(args, ValueRangeAll);
|
| if (!result)
|
| result = consumeNumber(args, ValueRangeAll);
|
| return result;
|
| }
|
|
|
| // Used to parse colors for -webkit-gradient(...).
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeDeprecatedGradientStopColor(CSSParserTokenRange& args, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeDeprecatedGradientStopColor(CSSParserTokenRange& args, CSSParserMode cssParserMode)
|
| {
|
| if (args.peek().id() == CSSValueCurrentcolor)
|
| return nullptr;
|
| @@ -2460,9 +2460,9 @@ static bool consumeDeprecatedGradientColorStop(CSSParserTokenRange& range, CSSGr
|
| return stop.m_color && args.atEnd();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeDeprecatedGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeDeprecatedGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode)
|
| {
|
| - RefPtrWillBeRawPtr<CSSGradientValue> result = nullptr;
|
| + RawPtr<CSSGradientValue> result = nullptr;
|
| CSSValueID id = args.consumeIncludingWhitespace().id();
|
| bool isDeprecatedRadialGradient = (id == CSSValueRadial);
|
| if (isDeprecatedRadialGradient)
|
| @@ -2472,7 +2472,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeDeprecatedGradient(CSSParserToken
|
| if (!result || !consumeCommaIncludingWhitespace(args))
|
| return nullptr;
|
|
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> point = consumeDeprecatedGradientPoint(args, true);
|
| + RawPtr<CSSPrimitiveValue> point = consumeDeprecatedGradientPoint(args, true);
|
| if (!point)
|
| return nullptr;
|
| result->setFirstX(point.release());
|
| @@ -2486,7 +2486,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeDeprecatedGradient(CSSParserToken
|
|
|
| // For radial gradients only, we now expect a numeric radius.
|
| if (isDeprecatedRadialGradient) {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> radius = consumeNumber(args, ValueRangeAll);
|
| + RawPtr<CSSPrimitiveValue> radius = consumeNumber(args, ValueRangeAll);
|
| if (!radius || !consumeCommaIncludingWhitespace(args))
|
| return nullptr;
|
| toCSSRadialGradientValue(result.get())->setFirstRadius(radius.release());
|
| @@ -2505,7 +2505,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeDeprecatedGradient(CSSParserToken
|
| if (isDeprecatedRadialGradient) {
|
| if (!consumeCommaIncludingWhitespace(args))
|
| return nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> radius = consumeNumber(args, ValueRangeAll);
|
| + RawPtr<CSSPrimitiveValue> radius = consumeNumber(args, ValueRangeAll);
|
| if (!radius)
|
| return nullptr;
|
| toCSSRadialGradientValue(result.get())->setSecondRadius(radius.release());
|
| @@ -2548,11 +2548,11 @@ static bool consumeGradientColorStops(CSSParserTokenRange& range, CSSParserMode
|
| return gradient->stopCount() >= 2;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeDeprecatedRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
|
| +static RawPtr<CSSValue> consumeDeprecatedRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
|
| {
|
| - RefPtrWillBeRawPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSPrefixedRadialGradient);
|
| - RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
|
| + RawPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSPrefixedRadialGradient);
|
| + RawPtr<CSSValue> centerX = nullptr;
|
| + RawPtr<CSSValue> centerY = nullptr;
|
| consumeOneOrTwoValuedPosition(args, cssParserMode, UnitlessQuirk::Forbid, centerX, centerY);
|
| if ((centerX || centerY) && !consumeCommaIncludingWhitespace(args))
|
| return nullptr;
|
| @@ -2562,8 +2562,8 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeDeprecatedRadialGradient(CSSParse
|
| result->setFirstY(toCSSPrimitiveValue(centerY.get()));
|
| result->setSecondY(toCSSPrimitiveValue(centerY.get()));
|
|
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> shape = consumeIdent<CSSValueCircle, CSSValueEllipse>(args);
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> sizeKeyword = consumeIdent<CSSValueClosestSide, CSSValueClosestCorner, CSSValueFarthestSide, CSSValueFarthestCorner, CSSValueContain, CSSValueCover>(args);
|
| + RawPtr<CSSPrimitiveValue> shape = consumeIdent<CSSValueCircle, CSSValueEllipse>(args);
|
| + RawPtr<CSSPrimitiveValue> sizeKeyword = consumeIdent<CSSValueClosestSide, CSSValueClosestCorner, CSSValueFarthestSide, CSSValueFarthestCorner, CSSValueContain, CSSValueCover>(args);
|
| if (!shape)
|
| shape = consumeIdent<CSSValueCircle, CSSValueEllipse>(args);
|
| result->setShape(shape);
|
| @@ -2571,8 +2571,8 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeDeprecatedRadialGradient(CSSParse
|
|
|
| // Or, two lengths or percentages
|
| if (!shape && !sizeKeyword) {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalSize = nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> verticalSize = nullptr;
|
| + RawPtr<CSSPrimitiveValue> horizontalSize = nullptr;
|
| + RawPtr<CSSPrimitiveValue> verticalSize = nullptr;
|
| if ((horizontalSize = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll))) {
|
| verticalSize = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
|
| if (!verticalSize)
|
| @@ -2590,14 +2590,14 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeDeprecatedRadialGradient(CSSParse
|
| return result.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
|
| +static RawPtr<CSSValue> consumeRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
|
| {
|
| - RefPtrWillBeRawPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSRadialGradient);
|
| + RawPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSRadialGradient);
|
|
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> shape = nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> sizeKeyword = nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalSize = nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> verticalSize = nullptr;
|
| + RawPtr<CSSPrimitiveValue> shape = nullptr;
|
| + RawPtr<CSSPrimitiveValue> sizeKeyword = nullptr;
|
| + RawPtr<CSSPrimitiveValue> horizontalSize = nullptr;
|
| + RawPtr<CSSPrimitiveValue> verticalSize = nullptr;
|
|
|
| // First part of grammar, the size/shape clause:
|
| // [ circle || <length> ] |
|
| @@ -2618,7 +2618,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeRadialGradient(CSSParserTokenRang
|
| break;
|
| }
|
| } else {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> center = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
|
| + RawPtr<CSSPrimitiveValue> center = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
|
| if (!center)
|
| break;
|
| if (horizontalSize)
|
| @@ -2650,8 +2650,8 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeRadialGradient(CSSParserTokenRang
|
| result->setEndHorizontalSize(horizontalSize);
|
| result->setEndVerticalSize(verticalSize);
|
|
|
| - RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
|
| + RawPtr<CSSValue> centerX = nullptr;
|
| + RawPtr<CSSValue> centerY = nullptr;
|
| if (args.peek().id() == CSSValueAt) {
|
| args.consumeIncludingWhitespace();
|
| consumePosition(args, cssParserMode, UnitlessQuirk::Forbid, centerX, centerY);
|
| @@ -2671,17 +2671,17 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeRadialGradient(CSSParserTokenRang
|
| return result.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeLinearGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating, CSSGradientType gradientType)
|
| +static RawPtr<CSSValue> consumeLinearGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating, CSSGradientType gradientType)
|
| {
|
| - RefPtrWillBeRawPtr<CSSLinearGradientValue> result = CSSLinearGradientValue::create(repeating, gradientType);
|
| + RawPtr<CSSLinearGradientValue> result = CSSLinearGradientValue::create(repeating, gradientType);
|
|
|
| bool expectComma = true;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> angle = consumeAngle(args, cssParserMode);
|
| + RawPtr<CSSPrimitiveValue> angle = consumeAngle(args, cssParserMode);
|
| if (angle) {
|
| result->setAngle(angle.release());
|
| } else if (gradientType == CSSPrefixedLinearGradient || consumeIdent<CSSValueTo>(args)) {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> endX = consumeIdent<CSSValueLeft, CSSValueRight>(args);
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> endY = consumeIdent<CSSValueBottom, CSSValueTop>(args);
|
| + RawPtr<CSSPrimitiveValue> endX = consumeIdent<CSSValueLeft, CSSValueRight>(args);
|
| + RawPtr<CSSPrimitiveValue> endY = consumeIdent<CSSValueBottom, CSSValueTop>(args);
|
| if (!endX && !endY) {
|
| if (gradientType == CSSLinearGradient)
|
| return nullptr;
|
| @@ -2704,18 +2704,18 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeLinearGradient(CSSParserTokenRang
|
| return result.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeImage(CSSParserTokenRange&, CSSParserContext);
|
| +static RawPtr<CSSValue> consumeImage(CSSParserTokenRange&, CSSParserContext);
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeCrossFade(CSSParserTokenRange& args, CSSParserContext context)
|
| +static RawPtr<CSSValue> consumeCrossFade(CSSParserTokenRange& args, CSSParserContext context)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValue> fromImageValue = consumeImage(args, context);
|
| + RawPtr<CSSValue> fromImageValue = consumeImage(args, context);
|
| if (!fromImageValue || !consumeCommaIncludingWhitespace(args))
|
| return nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> toImageValue = consumeImage(args, context);
|
| + RawPtr<CSSValue> toImageValue = consumeImage(args, context);
|
| if (!toImageValue || !consumeCommaIncludingWhitespace(args))
|
| return nullptr;
|
|
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> percentage = nullptr;
|
| + RawPtr<CSSPrimitiveValue> percentage = nullptr;
|
| const CSSParserToken& percentageArg = args.consumeIncludingWhitespace();
|
| if (percentageArg.type() == PercentageToken)
|
| percentage = cssValuePool().createValue(clampTo<double>(percentageArg.numericValue() / 100, 0, 1), CSSPrimitiveValue::UnitType::Number);
|
| @@ -2727,12 +2727,12 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeCrossFade(CSSParserTokenRange& ar
|
| return CSSCrossfadeValue::create(fromImageValue, toImageValue, percentage);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeGeneratedImage(CSSParserTokenRange& range, CSSParserContext context)
|
| +static RawPtr<CSSValue> consumeGeneratedImage(CSSParserTokenRange& range, CSSParserContext context)
|
| {
|
| CSSValueID id = range.peek().functionId();
|
| CSSParserTokenRange rangeCopy = range;
|
| CSSParserTokenRange args = consumeFunction(rangeCopy);
|
| - RefPtrWillBeRawPtr<CSSValue> result = nullptr;
|
| + RawPtr<CSSValue> result = nullptr;
|
| if (id == CSSValueRadialGradient) {
|
| result = consumeRadialGradient(args, context.mode(), NonRepeating);
|
| } else if (id == CSSValueWebkitLinearGradient) {
|
| @@ -2772,7 +2772,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeGeneratedImage(CSSParserTokenRang
|
| return result;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeImage(CSSParserTokenRange& range, CSSParserContext context)
|
| +static RawPtr<CSSValue> consumeImage(CSSParserTokenRange& range, CSSParserContext context)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
| @@ -2790,7 +2790,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeImage(CSSParserTokenRange& range,
|
| return nullptr;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeAttr(CSSParserTokenRange args, CSSParserContext context)
|
| +static RawPtr<CSSValue> consumeAttr(CSSParserTokenRange args, CSSParserContext context)
|
| {
|
| if (args.peek().type() != IdentToken)
|
| return nullptr;
|
| @@ -2806,19 +2806,19 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeAttr(CSSParserTokenRange args, CS
|
| if (context.isHTMLDocument())
|
| attrName = attrName.lower();
|
|
|
| - RefPtrWillBeRawPtr<CSSFunctionValue> attrValue = CSSFunctionValue::create(CSSValueAttr);
|
| + RawPtr<CSSFunctionValue> attrValue = CSSFunctionValue::create(CSSValueAttr);
|
| attrValue->append(CSSCustomIdentValue::create(attrName));
|
| return attrValue.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeCounterContent(CSSParserTokenRange args, bool counters)
|
| +static RawPtr<CSSValue> consumeCounterContent(CSSParserTokenRange args, bool counters)
|
| {
|
| - RefPtrWillBeRawPtr<CSSCustomIdentValue> identifier = consumeCustomIdent(args);
|
| + RawPtr<CSSCustomIdentValue> identifier = consumeCustomIdent(args);
|
| if (!identifier)
|
| return nullptr;
|
|
|
| // TODO(timloh): Make this a CSSStringValue.
|
| - RefPtrWillBeRawPtr<CSSCustomIdentValue> separator = nullptr;
|
| + RawPtr<CSSCustomIdentValue> separator = nullptr;
|
| if (!counters) {
|
| separator = CSSCustomIdentValue::create(String());
|
| } else {
|
| @@ -2829,7 +2829,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeCounterContent(CSSParserTokenRang
|
| separator = CSSCustomIdentValue::create(args.consumeIncludingWhitespace().value());
|
| }
|
|
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> listStyle = nullptr;
|
| + RawPtr<CSSPrimitiveValue> listStyle = nullptr;
|
| if (consumeCommaIncludingWhitespace(args)) {
|
| CSSValueID id = args.peek().id();
|
| if ((id != CSSValueNone && (id < CSSValueDisc || id > CSSValueKatakanaIroha)))
|
| @@ -2844,12 +2844,12 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeCounterContent(CSSParserTokenRang
|
| return CSSCounterValue::create(identifier.release(), listStyle.release(), separator.release());
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValueList> consumeContent(CSSParserTokenRange& range, CSSParserContext context)
|
| +static RawPtr<CSSValueList> consumeContent(CSSParserTokenRange& range, CSSParserContext context)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
|
| + RawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
|
|
|
| do {
|
| - RefPtrWillBeRawPtr<CSSValue> parsedValue = consumeImage(range, context);
|
| + RawPtr<CSSValue> parsedValue = consumeImage(range, context);
|
| if (!parsedValue)
|
| parsedValue = consumeIdent<CSSValueOpenQuote, CSSValueCloseQuote, CSSValueNoOpenQuote, CSSValueNoCloseQuote, CSSValueNormal>(range);
|
| if (!parsedValue)
|
| @@ -2870,11 +2870,11 @@ static PassRefPtrWillBeRawPtr<CSSValueList> consumeContent(CSSParserTokenRange&
|
| return values.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumePerspective(CSSParserTokenRange& range, CSSParserMode cssParserMode, CSSPropertyID unresolvedProperty)
|
| +static RawPtr<CSSPrimitiveValue> consumePerspective(CSSParserTokenRange& range, CSSParserMode cssParserMode, CSSPropertyID unresolvedProperty)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue = consumeLength(range, cssParserMode, ValueRangeAll);
|
| + RawPtr<CSSPrimitiveValue> parsedValue = consumeLength(range, cssParserMode, ValueRangeAll);
|
| if (!parsedValue && (unresolvedProperty == CSSPropertyAliasWebkitPerspective)) {
|
| double perspective;
|
| if (!consumeNumberRaw(range, perspective))
|
| @@ -2886,11 +2886,11 @@ static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumePerspective(CSSParserTok
|
| return nullptr;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValueList> consumePositionList(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValueList> consumePositionList(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValueList> positions = CSSValueList::createCommaSeparated();
|
| + RawPtr<CSSValueList> positions = CSSValueList::createCommaSeparated();
|
| do {
|
| - RefPtrWillBeRawPtr<CSSValue> position = consumePosition(range, cssParserMode, UnitlessQuirk::Forbid);
|
| + RawPtr<CSSValue> position = consumePosition(range, cssParserMode, UnitlessQuirk::Forbid);
|
| if (!position)
|
| return nullptr;
|
| positions->append(position);
|
| @@ -2898,22 +2898,22 @@ static PassRefPtrWillBeRawPtr<CSSValueList> consumePositionList(CSSParserTokenRa
|
| return positions.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeScrollSnapCoordinate(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeScrollSnapCoordinate(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
| return consumePositionList(range, cssParserMode);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeScrollSnapPoints(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeScrollSnapPoints(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
| if (range.peek().functionId() == CSSValueRepeat) {
|
| CSSParserTokenRange args = consumeFunction(range);
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRangeNonNegative);
|
| + RawPtr<CSSPrimitiveValue> parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRangeNonNegative);
|
| if (args.atEnd() && parsedValue && (parsedValue->isCalculated() || parsedValue->getDoubleValue() > 0)) {
|
| - RefPtrWillBeRawPtr<CSSFunctionValue> result = CSSFunctionValue::create(CSSValueRepeat);
|
| + RawPtr<CSSFunctionValue> result = CSSFunctionValue::create(CSSValueRepeat);
|
| result->append(parsedValue.release());
|
| return result.release();
|
| }
|
| @@ -2921,42 +2921,42 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeScrollSnapPoints(CSSParserTokenRa
|
| return nullptr;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeBorderRadiusCorner(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeBorderRadiusCorner(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValue> parsedValue1 = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
|
| + RawPtr<CSSValue> parsedValue1 = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
|
| if (!parsedValue1)
|
| return nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> parsedValue2 = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
|
| + RawPtr<CSSValue> parsedValue2 = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
|
| if (!parsedValue2)
|
| parsedValue2 = parsedValue1;
|
| return CSSValuePair::create(parsedValue1.release(), parsedValue2.release(), CSSValuePair::DropIdenticalValues);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeVerticalAlign(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSPrimitiveValue> consumeVerticalAlign(CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue = consumeIdentRange(range, CSSValueBaseline, CSSValueWebkitBaselineMiddle);
|
| + RawPtr<CSSPrimitiveValue> parsedValue = consumeIdentRange(range, CSSValueBaseline, CSSValueWebkitBaselineMiddle);
|
| if (!parsedValue)
|
| parsedValue = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
|
| return parsedValue.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeShapeRadius(CSSParserTokenRange& args, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSPrimitiveValue> consumeShapeRadius(CSSParserTokenRange& args, CSSParserMode cssParserMode)
|
| {
|
| if (identMatches<CSSValueClosestSide, CSSValueFarthestSide>(args.peek().id()))
|
| return consumeIdent(args);
|
| return consumeLengthOrPercent(args, cssParserMode, ValueRangeNonNegative);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSBasicShapeCircleValue> consumeBasicShapeCircle(CSSParserTokenRange& args, const CSSParserContext& context)
|
| +static RawPtr<CSSBasicShapeCircleValue> consumeBasicShapeCircle(CSSParserTokenRange& args, const CSSParserContext& context)
|
| {
|
| // spec: https://drafts.csswg.org/css-shapes/#supported-basic-shapes
|
| // circle( [<shape-radius>]? [at <position>]? )
|
| - RefPtrWillBeRawPtr<CSSBasicShapeCircleValue> shape = CSSBasicShapeCircleValue::create();
|
| - if (RefPtrWillBeRawPtr<CSSPrimitiveValue> radius = consumeShapeRadius(args, context.mode()))
|
| + RawPtr<CSSBasicShapeCircleValue> shape = CSSBasicShapeCircleValue::create();
|
| + if (RawPtr<CSSPrimitiveValue> radius = consumeShapeRadius(args, context.mode()))
|
| shape->setRadius(radius.release());
|
| if (consumeIdent<CSSValueAt>(args)) {
|
| - RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
|
| + RawPtr<CSSValue> centerX = nullptr;
|
| + RawPtr<CSSValue> centerY = nullptr;
|
| if (!consumePosition(args, context.mode(), UnitlessQuirk::Forbid, centerX, centerY))
|
| return nullptr;
|
| shape->setCenterX(centerX);
|
| @@ -2965,19 +2965,19 @@ static PassRefPtrWillBeRawPtr<CSSBasicShapeCircleValue> consumeBasicShapeCircle(
|
| return shape.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSBasicShapeEllipseValue> consumeBasicShapeEllipse(CSSParserTokenRange& args, const CSSParserContext& context)
|
| +static RawPtr<CSSBasicShapeEllipseValue> consumeBasicShapeEllipse(CSSParserTokenRange& args, const CSSParserContext& context)
|
| {
|
| // spec: https://drafts.csswg.org/css-shapes/#supported-basic-shapes
|
| // ellipse( [<shape-radius>{2}]? [at <position>]? )
|
| - RefPtrWillBeRawPtr<CSSBasicShapeEllipseValue> shape = CSSBasicShapeEllipseValue::create();
|
| - if (RefPtrWillBeRawPtr<CSSPrimitiveValue> radiusX = consumeShapeRadius(args, context.mode())) {
|
| + RawPtr<CSSBasicShapeEllipseValue> shape = CSSBasicShapeEllipseValue::create();
|
| + if (RawPtr<CSSPrimitiveValue> radiusX = consumeShapeRadius(args, context.mode())) {
|
| shape->setRadiusX(radiusX);
|
| - if (RefPtrWillBeRawPtr<CSSPrimitiveValue> radiusY = consumeShapeRadius(args, context.mode()))
|
| + if (RawPtr<CSSPrimitiveValue> radiusY = consumeShapeRadius(args, context.mode()))
|
| shape->setRadiusY(radiusY);
|
| }
|
| if (consumeIdent<CSSValueAt>(args)) {
|
| - RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
|
| + RawPtr<CSSValue> centerX = nullptr;
|
| + RawPtr<CSSValue> centerY = nullptr;
|
| if (!consumePosition(args, context.mode(), UnitlessQuirk::Forbid, centerX, centerY))
|
| return nullptr;
|
| shape->setCenterX(centerX);
|
| @@ -2986,9 +2986,9 @@ static PassRefPtrWillBeRawPtr<CSSBasicShapeEllipseValue> consumeBasicShapeEllips
|
| return shape.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSBasicShapePolygonValue> consumeBasicShapePolygon(CSSParserTokenRange& args, const CSSParserContext& context)
|
| +static RawPtr<CSSBasicShapePolygonValue> consumeBasicShapePolygon(CSSParserTokenRange& args, const CSSParserContext& context)
|
| {
|
| - RefPtrWillBeRawPtr<CSSBasicShapePolygonValue> shape = CSSBasicShapePolygonValue::create();
|
| + RawPtr<CSSBasicShapePolygonValue> shape = CSSBasicShapePolygonValue::create();
|
| if (identMatches<CSSValueEvenodd, CSSValueNonzero>(args.peek().id())) {
|
| shape->setWindRule(args.consumeIncludingWhitespace().id() == CSSValueEvenodd ? RULE_EVENODD : RULE_NONZERO);
|
| if (!consumeCommaIncludingWhitespace(args))
|
| @@ -2996,10 +2996,10 @@ static PassRefPtrWillBeRawPtr<CSSBasicShapePolygonValue> consumeBasicShapePolygo
|
| }
|
|
|
| do {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> xLength = consumeLengthOrPercent(args, context.mode(), ValueRangeAll);
|
| + RawPtr<CSSPrimitiveValue> xLength = consumeLengthOrPercent(args, context.mode(), ValueRangeAll);
|
| if (!xLength)
|
| return nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> yLength = consumeLengthOrPercent(args, context.mode(), ValueRangeAll);
|
| + RawPtr<CSSPrimitiveValue> yLength = consumeLengthOrPercent(args, context.mode(), ValueRangeAll);
|
| if (!yLength)
|
| return nullptr;
|
| shape->appendPoint(xLength.release(), yLength.release());
|
| @@ -3007,7 +3007,7 @@ static PassRefPtrWillBeRawPtr<CSSBasicShapePolygonValue> consumeBasicShapePolygo
|
| return shape.release();
|
| }
|
|
|
| -static void complete4Sides(RefPtrWillBeRawPtr<CSSPrimitiveValue> side[4])
|
| +static void complete4Sides(RawPtr<CSSPrimitiveValue> side[4])
|
| {
|
| if (side[3])
|
| return;
|
| @@ -3019,7 +3019,7 @@ static void complete4Sides(RefPtrWillBeRawPtr<CSSPrimitiveValue> side[4])
|
| side[3] = side[1];
|
| }
|
|
|
| -static bool consumeRadii(RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalRadii[4], RefPtrWillBeRawPtr<CSSPrimitiveValue> verticalRadii[4], CSSParserTokenRange& range, CSSParserMode cssParserMode, bool useLegacyParsing)
|
| +static bool consumeRadii(RawPtr<CSSPrimitiveValue> horizontalRadii[4], RawPtr<CSSPrimitiveValue> verticalRadii[4], CSSParserTokenRange& range, CSSParserMode cssParserMode, bool useLegacyParsing)
|
| {
|
| #if ENABLE(OILPAN)
|
| // Unconditionally zero initialize the arrays of raw pointers.
|
| @@ -3062,15 +3062,15 @@ static bool consumeRadii(RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalRadii[4
|
| return true;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSBasicShapeInsetValue> consumeBasicShapeInset(CSSParserTokenRange& args, const CSSParserContext& context)
|
| +static RawPtr<CSSBasicShapeInsetValue> consumeBasicShapeInset(CSSParserTokenRange& args, const CSSParserContext& context)
|
| {
|
| - RefPtrWillBeRawPtr<CSSBasicShapeInsetValue> shape = CSSBasicShapeInsetValue::create();
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> top = consumeLengthOrPercent(args, context.mode(), ValueRangeAll);
|
| + RawPtr<CSSBasicShapeInsetValue> shape = CSSBasicShapeInsetValue::create();
|
| + RawPtr<CSSPrimitiveValue> top = consumeLengthOrPercent(args, context.mode(), ValueRangeAll);
|
| if (!top)
|
| return nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> right = nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> bottom = nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> left = nullptr;
|
| + RawPtr<CSSPrimitiveValue> right = nullptr;
|
| + RawPtr<CSSPrimitiveValue> bottom = nullptr;
|
| + RawPtr<CSSPrimitiveValue> left = nullptr;
|
| if ((right = consumeLengthOrPercent(args, context.mode(), ValueRangeAll))) {
|
| if ((bottom = consumeLengthOrPercent(args, context.mode(), ValueRangeAll)))
|
| left = consumeLengthOrPercent(args, context.mode(), ValueRangeAll);
|
| @@ -3085,8 +3085,8 @@ static PassRefPtrWillBeRawPtr<CSSBasicShapeInsetValue> consumeBasicShapeInset(CS
|
| shape->updateShapeSize1Value(top.get());
|
|
|
| if (consumeIdent<CSSValueRound>(args)) {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalRadii[4];
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> verticalRadii[4];
|
| + RawPtr<CSSPrimitiveValue> horizontalRadii[4];
|
| + RawPtr<CSSPrimitiveValue> verticalRadii[4];
|
| if (!consumeRadii(horizontalRadii, verticalRadii, args, context.mode(), false))
|
| return nullptr;
|
| shape->setTopLeftRadius(CSSValuePair::create(horizontalRadii[0].release(), verticalRadii[0].release(), CSSValuePair::DropIdenticalValues));
|
| @@ -3097,9 +3097,9 @@ static PassRefPtrWillBeRawPtr<CSSBasicShapeInsetValue> consumeBasicShapeInset(CS
|
| return shape.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeBasicShape(CSSParserTokenRange& range, const CSSParserContext& context)
|
| +static RawPtr<CSSValue> consumeBasicShape(CSSParserTokenRange& range, const CSSParserContext& context)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValue> shape = nullptr;
|
| + RawPtr<CSSValue> shape = nullptr;
|
| if (range.peek().type() != FunctionToken)
|
| return nullptr;
|
| CSSValueID id = range.peek().functionId();
|
| @@ -3119,7 +3119,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeBasicShape(CSSParserTokenRange& r
|
| return shape.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeClipPath(CSSParserTokenRange& range, const CSSParserContext& context)
|
| +static RawPtr<CSSValue> consumeClipPath(CSSParserTokenRange& range, const CSSParserContext& context)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
| @@ -3129,19 +3129,19 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeClipPath(CSSParserTokenRange& ran
|
| return consumeBasicShape(range, context);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeShapeOutside(CSSParserTokenRange& range, const CSSParserContext& context)
|
| +static RawPtr<CSSValue> consumeShapeOutside(CSSParserTokenRange& range, const CSSParserContext& context)
|
| {
|
| if (range.peek().id() == CSSValueNone)
|
| return consumeIdent(range);
|
| - if (RefPtrWillBeRawPtr<CSSValue> imageValue = consumeImage(range, context))
|
| + if (RawPtr<CSSValue> imageValue = consumeImage(range, context))
|
| return imageValue.release();
|
| - RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| - if (RefPtrWillBeRawPtr<CSSValue> boxValue = consumeIdent<CSSValueContentBox, CSSValuePaddingBox, CSSValueBorderBox, CSSValueMarginBox>(range))
|
| + RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + if (RawPtr<CSSValue> boxValue = consumeIdent<CSSValueContentBox, CSSValuePaddingBox, CSSValueBorderBox, CSSValueMarginBox>(range))
|
| list->append(boxValue.release());
|
| - if (RefPtrWillBeRawPtr<CSSValue> shapeValue = consumeBasicShape(range, context)) {
|
| + if (RawPtr<CSSValue> shapeValue = consumeBasicShape(range, context)) {
|
| list->append(shapeValue.release());
|
| if (list->length() < 2) {
|
| - if (RefPtrWillBeRawPtr<CSSValue> boxValue = consumeIdent<CSSValueContentBox, CSSValuePaddingBox, CSSValueBorderBox, CSSValueMarginBox>(range))
|
| + if (RawPtr<CSSValue> boxValue = consumeIdent<CSSValueContentBox, CSSValuePaddingBox, CSSValueBorderBox, CSSValueMarginBox>(range))
|
| list->append(boxValue.release());
|
| }
|
| }
|
| @@ -3150,7 +3150,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeShapeOutside(CSSParserTokenRange&
|
| return list.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeContentDistributionOverflowPosition(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeContentDistributionOverflowPosition(CSSParserTokenRange& range)
|
| {
|
| if (identMatches<CSSValueAuto, CSSValueBaseline, CSSValueLastBaseline>(range.peek().id()))
|
| return CSSContentDistributionValue::create(CSSValueInvalid, range.consumeIncludingWhitespace().id(), CSSValueInvalid);
|
| @@ -3189,32 +3189,32 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeContentDistributionOverflowPositi
|
| return CSSContentDistributionValue::create(distribution, position, overflow);
|
| }
|
|
|
| -static RefPtrWillBeRawPtr<CSSPrimitiveValue> consumeBorderImageRepeatKeyword(CSSParserTokenRange& range)
|
| +static RawPtr<CSSPrimitiveValue> consumeBorderImageRepeatKeyword(CSSParserTokenRange& range)
|
| {
|
| return consumeIdent<CSSValueStretch, CSSValueRepeat, CSSValueSpace, CSSValueRound>(range);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeBorderImageRepeat(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeBorderImageRepeat(CSSParserTokenRange& range)
|
| {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontal = consumeBorderImageRepeatKeyword(range);
|
| + RawPtr<CSSPrimitiveValue> horizontal = consumeBorderImageRepeatKeyword(range);
|
| if (!horizontal)
|
| return nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> vertical = consumeBorderImageRepeatKeyword(range);
|
| + RawPtr<CSSPrimitiveValue> vertical = consumeBorderImageRepeatKeyword(range);
|
| if (!vertical)
|
| vertical = horizontal;
|
| return CSSValuePair::create(horizontal.release(), vertical.release(), CSSValuePair::DropIdenticalValues);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeBorderImageSlice(CSSPropertyID property, CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeBorderImageSlice(CSSPropertyID property, CSSParserTokenRange& range, CSSParserMode cssParserMode)
|
| {
|
| bool fill = consumeIdent<CSSValueFill>(range);
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> slices[4];
|
| + RawPtr<CSSPrimitiveValue> slices[4];
|
| #if ENABLE(OILPAN)
|
| // Unconditionally zero initialize the arrays of raw pointers.
|
| memset(slices, 0, 4 * sizeof(slices[0]));
|
| #endif
|
| for (size_t index = 0; index < 4; ++index) {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> value = consumePercent(range, ValueRangeNonNegative);
|
| + RawPtr<CSSPrimitiveValue> value = consumePercent(range, ValueRangeNonNegative);
|
| if (!value)
|
| value = consumeNumber(range, ValueRangeNonNegative);
|
| if (!value)
|
| @@ -3236,14 +3236,14 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeBorderImageSlice(CSSPropertyID pr
|
| return CSSBorderImageSliceValue::create(CSSQuadValue::create(slices[0].release(), slices[1].release(), slices[2].release(), slices[3].release(), CSSQuadValue::SerializeAsQuad), fill);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeBorderImageOutset(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeBorderImageOutset(CSSParserTokenRange& range)
|
| {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> outsets[4];
|
| + RawPtr<CSSPrimitiveValue> outsets[4];
|
| #if ENABLE(OILPAN)
|
| // Unconditionally zero initialize the arrays of raw pointers.
|
| memset(outsets, 0, 4 * sizeof(outsets[0]));
|
| #endif
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> value = nullptr;
|
| + RawPtr<CSSPrimitiveValue> value = nullptr;
|
| for (size_t index = 0; index < 4; ++index) {
|
| value = consumeNumber(range, ValueRangeNonNegative);
|
| if (!value)
|
| @@ -3258,14 +3258,14 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeBorderImageOutset(CSSParserTokenR
|
| return CSSQuadValue::create(outsets[0].release(), outsets[1].release(), outsets[2].release(), outsets[3].release(), CSSQuadValue::SerializeAsQuad);
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeBorderImageWidth(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValue> consumeBorderImageWidth(CSSParserTokenRange& range)
|
| {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> widths[4];
|
| + RawPtr<CSSPrimitiveValue> widths[4];
|
| #if ENABLE(OILPAN)
|
| // Unconditionally zero initialize the arrays of raw pointers.
|
| memset(widths, 0, 4 * sizeof(widths[0]));
|
| #endif
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> value = nullptr;
|
| + RawPtr<CSSPrimitiveValue> value = nullptr;
|
| for (size_t index = 0; index < 4; ++index) {
|
| value = consumeNumber(range, ValueRangeNonNegative);
|
| if (!value)
|
| @@ -3282,7 +3282,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeBorderImageWidth(CSSParserTokenRa
|
| return CSSQuadValue::create(widths[0].release(), widths[1].release(), widths[2].release(), widths[3].release(), CSSQuadValue::SerializeAsQuad);
|
| }
|
|
|
| -PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID unresolvedProperty)
|
| +RawPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID unresolvedProperty)
|
| {
|
| CSSPropertyID property = resolveCSSPropertyID(unresolvedProperty);
|
| if (CSSParserFastPaths::isKeywordPropertyID(property)) {
|
| @@ -3602,7 +3602,7 @@ PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSProperty
|
| CSSParserValueList valueList(m_range);
|
| if (valueList.size()) {
|
| m_valueList = &valueList;
|
| - if (RefPtrWillBeRawPtr<CSSValue> result = legacyParseValue(unresolvedProperty)) {
|
| + if (RawPtr<CSSValue> result = legacyParseValue(unresolvedProperty)) {
|
| while (!m_range.atEnd())
|
| m_range.consume();
|
| return result.release();
|
| @@ -3612,9 +3612,9 @@ PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSProperty
|
| }
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValueList> consumeFontFaceUnicodeRange(CSSParserTokenRange& range)
|
| +static RawPtr<CSSValueList> consumeFontFaceUnicodeRange(CSSParserTokenRange& range)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
|
| + RawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
|
|
|
| do {
|
| const CSSParserToken& token = range.consumeIncludingWhitespace();
|
| @@ -3631,12 +3631,12 @@ static PassRefPtrWillBeRawPtr<CSSValueList> consumeFontFaceUnicodeRange(CSSParse
|
| return values.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeFontFaceSrcURI(CSSParserTokenRange& range, const CSSParserContext& context)
|
| +static RawPtr<CSSValue> consumeFontFaceSrcURI(CSSParserTokenRange& range, const CSSParserContext& context)
|
| {
|
| String url = consumeUrl(range);
|
| if (url.isNull())
|
| return nullptr;
|
| - RefPtrWillBeRawPtr<CSSFontFaceSrcValue> uriValue(CSSFontFaceSrcValue::create(context.completeURL(url), context.shouldCheckContentSecurityPolicy()));
|
| + RawPtr<CSSFontFaceSrcValue> uriValue(CSSFontFaceSrcValue::create(context.completeURL(url), context.shouldCheckContentSecurityPolicy()));
|
| uriValue->setReferrer(context.referrer());
|
|
|
| if (range.peek().functionId() != CSSValueFormat)
|
| @@ -3653,7 +3653,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeFontFaceSrcURI(CSSParserTokenRang
|
| return uriValue.release();
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeFontFaceSrcLocal(CSSParserTokenRange& range, const CSSParserContext& context)
|
| +static RawPtr<CSSValue> consumeFontFaceSrcLocal(CSSParserTokenRange& range, const CSSParserContext& context)
|
| {
|
| CSSParserTokenRange args = consumeFunction(range);
|
| ContentSecurityPolicyDisposition shouldCheckContentSecurityPolicy = context.shouldCheckContentSecurityPolicy();
|
| @@ -3672,13 +3672,13 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeFontFaceSrcLocal(CSSParserTokenRa
|
| return nullptr;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValueList> consumeFontFaceSrc(CSSParserTokenRange& range, const CSSParserContext& context)
|
| +static RawPtr<CSSValueList> consumeFontFaceSrc(CSSParserTokenRange& range, const CSSParserContext& context)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValueList> values(CSSValueList::createCommaSeparated());
|
| + RawPtr<CSSValueList> values(CSSValueList::createCommaSeparated());
|
|
|
| do {
|
| const CSSParserToken& token = range.peek();
|
| - RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
|
| + RawPtr<CSSValue> parsedValue = nullptr;
|
| if (token.functionId() == CSSValueLocal)
|
| parsedValue = consumeFontFaceSrcLocal(range, context);
|
| else
|
| @@ -3692,7 +3692,7 @@ static PassRefPtrWillBeRawPtr<CSSValueList> consumeFontFaceSrc(CSSParserTokenRan
|
|
|
| bool CSSPropertyParser::parseFontFaceDescriptor(CSSPropertyID propId)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
|
| + RawPtr<CSSValue> parsedValue = nullptr;
|
| switch (propId) {
|
| case CSSPropertyFontFamily:
|
| if (consumeGenericFamily(m_range))
|
| @@ -3750,7 +3750,7 @@ bool CSSPropertyParser::consumeSystemFont(bool important)
|
| addProperty(CSSPropertyFontStyle, cssValuePool().createIdentifierValue(fontStyle == FontStyleItalic ? CSSValueItalic : CSSValueNormal), important);
|
| addProperty(CSSPropertyFontWeight, cssValuePool().createValue(fontWeight), important);
|
| addProperty(CSSPropertyFontSize, cssValuePool().createValue(fontSize, CSSPrimitiveValue::UnitType::Pixels), important);
|
| - RefPtrWillBeRawPtr<CSSValueList> fontFamilyList = CSSValueList::createCommaSeparated();
|
| + RawPtr<CSSValueList> fontFamilyList = CSSValueList::createCommaSeparated();
|
| fontFamilyList->append(cssValuePool().createFontFamilyValue(fontFamily));
|
| addProperty(CSSPropertyFontFamily, fontFamilyList.release(), important);
|
|
|
| @@ -3770,10 +3770,10 @@ bool CSSPropertyParser::consumeFont(bool important)
|
| return false;
|
| }
|
| // Optional font-style, font-variant, font-stretch and font-weight.
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> fontStyle = nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> fontVariant = nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> fontWeight = nullptr;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> fontStretch = nullptr;
|
| + RawPtr<CSSPrimitiveValue> fontStyle = nullptr;
|
| + RawPtr<CSSPrimitiveValue> fontVariant = nullptr;
|
| + RawPtr<CSSPrimitiveValue> fontWeight = nullptr;
|
| + RawPtr<CSSPrimitiveValue> fontStretch = nullptr;
|
| while (!m_range.atEnd()) {
|
| CSSValueID id = m_range.peek().id();
|
| if (!fontStyle && CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyFontStyle, id)) {
|
| @@ -3806,7 +3806,7 @@ bool CSSPropertyParser::consumeFont(bool important)
|
| addProperty(CSSPropertyFontStretch, fontStretch ? fontStretch.release() : cssValuePool().createIdentifierValue(CSSValueNormal), important);
|
|
|
| // Now a font size _must_ come.
|
| - RefPtrWillBeRawPtr<CSSValue> fontSize = consumeFontSize(m_range, m_context.mode());
|
| + RawPtr<CSSValue> fontSize = consumeFontSize(m_range, m_context.mode());
|
| if (!fontSize || m_range.atEnd())
|
| return false;
|
|
|
| @@ -3814,7 +3814,7 @@ bool CSSPropertyParser::consumeFont(bool important)
|
|
|
| if (m_range.peek().type() == DelimiterToken && m_range.peek().delimiter() == '/') {
|
| m_range.consumeIncludingWhitespace();
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> lineHeight = consumeLineHeight(m_range, m_context.mode());
|
| + RawPtr<CSSPrimitiveValue> lineHeight = consumeLineHeight(m_range, m_context.mode());
|
| if (!lineHeight)
|
| return false;
|
| addProperty(CSSPropertyLineHeight, lineHeight.release(), important);
|
| @@ -3823,7 +3823,7 @@ bool CSSPropertyParser::consumeFont(bool important)
|
| }
|
|
|
| // Font family must come now.
|
| - RefPtrWillBeRawPtr<CSSValue> parsedFamilyValue = consumeFontFamily(m_range);
|
| + RawPtr<CSSValue> parsedFamilyValue = consumeFontFamily(m_range);
|
| if (!parsedFamilyValue)
|
| return false;
|
|
|
| @@ -3837,10 +3837,10 @@ bool CSSPropertyParser::consumeFont(bool important)
|
|
|
| bool CSSPropertyParser::consumeBorderSpacing(bool important)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValue> horizontalSpacing = consumeLength(m_range, m_context.mode(), ValueRangeNonNegative, UnitlessQuirk::Allow);
|
| + RawPtr<CSSValue> horizontalSpacing = consumeLength(m_range, m_context.mode(), ValueRangeNonNegative, UnitlessQuirk::Allow);
|
| if (!horizontalSpacing)
|
| return false;
|
| - RefPtrWillBeRawPtr<CSSValue> verticalSpacing = horizontalSpacing;
|
| + RawPtr<CSSValue> verticalSpacing = horizontalSpacing;
|
| if (!m_range.atEnd())
|
| verticalSpacing = consumeLength(m_range, m_context.mode(), ValueRangeNonNegative, UnitlessQuirk::Allow);
|
| if (!verticalSpacing || !m_range.atEnd())
|
| @@ -3850,7 +3850,7 @@ bool CSSPropertyParser::consumeBorderSpacing(bool important)
|
| return true;
|
| }
|
|
|
| -static PassRefPtrWillBeRawPtr<CSSValue> consumeSingleViewportDescriptor(CSSParserTokenRange& range, CSSPropertyID propId, CSSParserMode cssParserMode)
|
| +static RawPtr<CSSValue> consumeSingleViewportDescriptor(CSSParserTokenRange& range, CSSPropertyID propId, CSSParserMode cssParserMode)
|
| {
|
| CSSValueID id = range.peek().id();
|
| switch (propId) {
|
| @@ -3866,7 +3866,7 @@ static PassRefPtrWillBeRawPtr<CSSValue> consumeSingleViewportDescriptor(CSSParse
|
| case CSSPropertyZoom: {
|
| if (id == CSSValueAuto)
|
| return consumeIdent(range);
|
| - RefPtrWillBeRawPtr<CSSValue> parsedValue = consumeNumber(range, ValueRangeNonNegative);
|
| + RawPtr<CSSValue> parsedValue = consumeNumber(range, ValueRangeNonNegative);
|
| if (parsedValue)
|
| return parsedValue.release();
|
| return consumePercent(range, ValueRangeNonNegative);
|
| @@ -3890,10 +3890,10 @@ bool CSSPropertyParser::parseViewportDescriptor(CSSPropertyID propId, bool impor
|
|
|
| switch (propId) {
|
| case CSSPropertyWidth: {
|
| - RefPtrWillBeRawPtr<CSSValue> minWidth = consumeSingleViewportDescriptor(m_range, CSSPropertyMinWidth, m_context.mode());
|
| + RawPtr<CSSValue> minWidth = consumeSingleViewportDescriptor(m_range, CSSPropertyMinWidth, m_context.mode());
|
| if (!minWidth)
|
| return false;
|
| - RefPtrWillBeRawPtr<CSSValue> maxWidth = minWidth;
|
| + RawPtr<CSSValue> maxWidth = minWidth;
|
| if (!m_range.atEnd())
|
| maxWidth = consumeSingleViewportDescriptor(m_range, CSSPropertyMaxWidth, m_context.mode());
|
| if (!maxWidth || !m_range.atEnd())
|
| @@ -3903,10 +3903,10 @@ bool CSSPropertyParser::parseViewportDescriptor(CSSPropertyID propId, bool impor
|
| return true;
|
| }
|
| case CSSPropertyHeight: {
|
| - RefPtrWillBeRawPtr<CSSValue> minHeight = consumeSingleViewportDescriptor(m_range, CSSPropertyMinHeight, m_context.mode());
|
| + RawPtr<CSSValue> minHeight = consumeSingleViewportDescriptor(m_range, CSSPropertyMinHeight, m_context.mode());
|
| if (!minHeight)
|
| return false;
|
| - RefPtrWillBeRawPtr<CSSValue> maxHeight = minHeight;
|
| + RawPtr<CSSValue> maxHeight = minHeight;
|
| if (!m_range.atEnd())
|
| maxHeight = consumeSingleViewportDescriptor(m_range, CSSPropertyMaxHeight, m_context.mode());
|
| if (!maxHeight || !m_range.atEnd())
|
| @@ -3924,7 +3924,7 @@ bool CSSPropertyParser::parseViewportDescriptor(CSSPropertyID propId, bool impor
|
| case CSSPropertyZoom:
|
| case CSSPropertyUserZoom:
|
| case CSSPropertyOrientation: {
|
| - RefPtrWillBeRawPtr<CSSValue> parsedValue = consumeSingleViewportDescriptor(m_range, propId, m_context.mode());
|
| + RawPtr<CSSValue> parsedValue = consumeSingleViewportDescriptor(m_range, propId, m_context.mode());
|
| if (!parsedValue || !m_range.atEnd())
|
| return false;
|
| addProperty(propId, parsedValue.release(), important);
|
| @@ -3935,7 +3935,7 @@ bool CSSPropertyParser::parseViewportDescriptor(CSSPropertyID propId, bool impor
|
| }
|
| }
|
|
|
| -static bool consumeColumnWidthOrCount(CSSParserTokenRange& range, CSSParserMode cssParserMode, RefPtrWillBeRawPtr<CSSValue> &columnWidth, RefPtrWillBeRawPtr<CSSValue> &columnCount)
|
| +static bool consumeColumnWidthOrCount(CSSParserTokenRange& range, CSSParserMode cssParserMode, RawPtr<CSSValue> &columnWidth, RawPtr<CSSValue> &columnCount)
|
| {
|
| if (range.peek().id() == CSSValueAuto) {
|
| consumeIdent(range);
|
| @@ -3952,8 +3952,8 @@ static bool consumeColumnWidthOrCount(CSSParserTokenRange& range, CSSParserMode
|
|
|
| bool CSSPropertyParser::consumeColumns(bool important)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValue> columnWidth = nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> columnCount = nullptr;
|
| + RawPtr<CSSValue> columnWidth = nullptr;
|
| + RawPtr<CSSValue> columnCount = nullptr;
|
| if (!consumeColumnWidthOrCount(m_range, m_context.mode(), columnWidth, columnCount))
|
| return false;
|
| consumeColumnWidthOrCount(m_range, m_context.mode(), columnWidth, columnCount);
|
| @@ -3971,7 +3971,7 @@ bool CSSPropertyParser::consumeColumns(bool important)
|
| bool CSSPropertyParser::consumeShorthandGreedily(const StylePropertyShorthand& shorthand, bool important)
|
| {
|
| ASSERT(shorthand.length() <= 6); // Existing shorthands have at most 6 longhands.
|
| - RefPtrWillBeRawPtr<CSSValue> longhands[6] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
|
| + RawPtr<CSSValue> longhands[6] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
|
| const CSSPropertyID* shorthandProperties = shorthand.properties();
|
| do {
|
| bool foundLonghand = false;
|
| @@ -4002,7 +4002,7 @@ bool CSSPropertyParser::consumeFlex(bool important)
|
| static const double unsetValue = -1;
|
| double flexGrow = unsetValue;
|
| double flexShrink = unsetValue;
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> flexBasis = nullptr;
|
| + RawPtr<CSSPrimitiveValue> flexBasis = nullptr;
|
|
|
| if (m_range.peek().id() == CSSValueNone) {
|
| flexGrow = 0;
|
| @@ -4053,9 +4053,9 @@ bool CSSPropertyParser::consumeFlex(bool important)
|
|
|
| bool CSSPropertyParser::consumeBorder(bool important)
|
| {
|
| - RefPtrWillBeRawPtr<CSSValue> width = nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> style = nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> color = nullptr;
|
| + RawPtr<CSSValue> width = nullptr;
|
| + RawPtr<CSSValue> style = nullptr;
|
| + RawPtr<CSSValue> color = nullptr;
|
|
|
| while (!width || !style || !color) {
|
| if (!width && (width = consumeLineWidth(m_range, m_context.mode(), UnitlessQuirk::Forbid)))
|
| @@ -4089,13 +4089,13 @@ bool CSSPropertyParser::consume4Values(const StylePropertyShorthand& shorthand,
|
| {
|
| ASSERT(shorthand.length() == 4);
|
| const CSSPropertyID* longhands = shorthand.properties();
|
| - RefPtrWillBeRawPtr<CSSValue> top = parseSingleValue(longhands[0]);
|
| + RawPtr<CSSValue> top = parseSingleValue(longhands[0]);
|
| if (!top)
|
| return false;
|
|
|
| - RefPtrWillBeRawPtr<CSSValue> right = nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> bottom = nullptr;
|
| - RefPtrWillBeRawPtr<CSSValue> left = nullptr;
|
| + RawPtr<CSSValue> right = nullptr;
|
| + RawPtr<CSSValue> bottom = nullptr;
|
| + RawPtr<CSSValue> left = nullptr;
|
| if ((right = parseSingleValue(longhands[1]))) {
|
| if ((bottom = parseSingleValue(longhands[2])))
|
| left = parseSingleValue(longhands[3]);
|
| @@ -4128,7 +4128,7 @@ bool CSSPropertyParser::parseShorthand(CSSPropertyID unresolvedProperty, bool im
|
| CSSValueID id = m_range.consumeIncludingWhitespace().id();
|
| if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyWebkitMarginBeforeCollapse, id))
|
| return false;
|
| - RefPtrWillBeRawPtr<CSSValue> beforeCollapse = cssValuePool().createIdentifierValue(id);
|
| + RawPtr<CSSValue> beforeCollapse = cssValuePool().createIdentifierValue(id);
|
| addProperty(CSSPropertyWebkitMarginBeforeCollapse, beforeCollapse, important);
|
| if (m_range.atEnd()) {
|
| addProperty(CSSPropertyWebkitMarginAfterCollapse, beforeCollapse, important);
|
| @@ -4146,9 +4146,9 @@ bool CSSPropertyParser::parseShorthand(CSSPropertyID unresolvedProperty, bool im
|
| return false;
|
| if (!m_range.atEnd())
|
| return false;
|
| - RefPtrWillBeRawPtr<CSSValue> overflowYValue = cssValuePool().createIdentifierValue(id);
|
| + RawPtr<CSSValue> overflowYValue = cssValuePool().createIdentifierValue(id);
|
|
|
| - RefPtrWillBeRawPtr<CSSValue> overflowXValue = nullptr;
|
| + RawPtr<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
|
| @@ -4204,7 +4204,7 @@ bool CSSPropertyParser::parseShorthand(CSSPropertyID unresolvedProperty, bool im
|
| return consumeShorthandGreedily(webkitTextStrokeShorthand(), important);
|
| case CSSPropertyMarker: {
|
| ImplicitScope implicitScope(this);
|
| - RefPtrWillBeRawPtr<CSSValue> marker = parseSingleValue(CSSPropertyMarkerStart);
|
| + RawPtr<CSSValue> marker = parseSingleValue(CSSPropertyMarkerStart);
|
| if (!marker || !m_range.atEnd())
|
| return false;
|
| addProperty(CSSPropertyMarkerStart, marker, important);
|
| @@ -4221,8 +4221,8 @@ bool CSSPropertyParser::parseShorthand(CSSPropertyID unresolvedProperty, bool im
|
| case CSSPropertyListStyle:
|
| return consumeShorthandGreedily(listStyleShorthand(), important);
|
| case CSSPropertyBorderRadius: {
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalRadii[4];
|
| - RefPtrWillBeRawPtr<CSSPrimitiveValue> verticalRadii[4];
|
| + RawPtr<CSSPrimitiveValue> horizontalRadii[4];
|
| + RawPtr<CSSPrimitiveValue> verticalRadii[4];
|
| if (!consumeRadii(horizontalRadii, verticalRadii, m_range, m_context.mode(), unresolvedProperty == CSSPropertyAliasWebkitBorderRadius))
|
| return false;
|
| addProperty(CSSPropertyBorderTopLeftRadius, CSSValuePair::create(horizontalRadii[0].release(), verticalRadii[0].release(), CSSValuePair::DropIdenticalValues), important);
|
|
|
Chromium Code Reviews
Issue 1686483002:
Oilpan: Remove most WillBe types from the code base (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master