Remove RawPtr from core/css

third_party/WebKit/Source/core/css/parser/LegacyCSSPropertyParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 22 matching lines @@
 #include "core/css/CSSGridLineNamesValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSValuePair.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/parser/CSSParserValues.h"
 #include "core/style/GridArea.h"
 #include "platform/RuntimeEnabledFeatures.h"
 
 namespace blink {
 
-void CSSPropertyParser::addProperty(CSSPropertyID propId, RawPtr<CSSValue> value, bool important, bool implicit)
+void CSSPropertyParser::addProperty(CSSPropertyID propId, CSSValue* value, bool important, bool implicit)
 {
     ASSERT(!isPropertyAlias(propId));
 
     int shorthandIndex = 0;
     bool setFromShorthand = false;
 
     if (m_currentShorthand) {
         Vector<StylePropertyShorthand, 4> shorthands;
         getMatchingShorthandsForLonghand(propId, &shorthands);
         setFromShorthand = true;
@@ skipping 131 matching lines @@
         return unitflags & FAngle;
     case CSSPrimitiveValue::UnitType::DotsPerPixel:
     case CSSPrimitiveValue::UnitType::DotsPerInch:
     case CSSPrimitiveValue::UnitType::DotsPerCentimeter:
         return unitflags & FResolution;
     default:
         return false;
     }
 }
 
-RawPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveNumericValue(CSSParserValue* value)
+CSSPrimitiveValue* CSSPropertyParser::createPrimitiveNumericValue(CSSParserValue* value)
 {
     if (m_parsedCalculation) {
         ASSERT(isCalculation(value));
         return CSSPrimitiveValue::create(m_parsedCalculation.release());
     }
 
     ASSERT((value->unit() >= CSSPrimitiveValue::UnitType::Number && value->unit() <= CSSPrimitiveValue::UnitType::Kilohertz)
         || (value->unit() >= CSSPrimitiveValue::UnitType::Turns && value->unit() <= CSSPrimitiveValue::UnitType::Chs)
         || (value->unit() >= CSSPrimitiveValue::UnitType::ViewportWidth && value->unit() <= CSSPrimitiveValue::UnitType::ViewportMax)
         || (value->unit() >= CSSPrimitiveValue::UnitType::DotsPerPixel && value->unit() <= CSSPrimitiveValue::UnitType::DotsPerCentimeter));
     return cssValuePool().createValue(value->fValue, value->unit());
 }
 
-inline RawPtr<CSSCustomIdentValue> CSSPropertyParser::createPrimitiveCustomIdentValue(CSSParserValue* value)
+inline CSSCustomIdentValue* CSSPropertyParser::createPrimitiveCustomIdentValue(CSSParserValue* value)
 {
     ASSERT(value->m_unit == CSSParserValue::String || value->m_unit == CSSParserValue::Identifier);
     return CSSCustomIdentValue::create(value->string);
 }
 
 static inline bool isComma(CSSParserValue* value)
 {
     ASSERT(value);
     return value->m_unit == CSSParserValue::Operator && value->iValue == ',';
 }
 
 static inline bool isForwardSlashOperator(CSSParserValue* value)
 {
     ASSERT(value);
     return value->m_unit == CSSParserValue::Operator && value->iValue == '/';
 }
 
-void CSSPropertyParser::addExpandedPropertyForValue(CSSPropertyID propId, RawPtr<CSSValue> prpValue, bool important)
+void CSSPropertyParser::addExpandedPropertyForValue(CSSPropertyID propId, CSSValue* value, bool important)
 {
     const StylePropertyShorthand& shorthand = shorthandForProperty(propId);
     unsigned shorthandLength = shorthand.length();
     if (!shorthandLength) {
-        addProperty(propId, prpValue, important);
+        addProperty(propId, value, important);
         return;
     }
 
-    RawPtr<CSSValue> value = prpValue;
     ShorthandScope scope(this, propId);
     const CSSPropertyID* longhands = shorthand.properties();
     for (unsigned i = 0; i < shorthandLength; ++i)
         addProperty(longhands[i], value, important);
 }
 
 bool CSSPropertyParser::legacyParseAndApplyValue(CSSPropertyID propertyID, bool important)
 {
-    RawPtr<CSSValue> result = legacyParseValue(propertyID);
+    CSSValue* result = legacyParseValue(propertyID);
     if (!result)
         return false;
-    addProperty(propertyID, result.release(), important);
+    addProperty(propertyID, result, important);
     return true;
 }
 
-RawPtr<CSSValue> CSSPropertyParser::legacyParseValue(CSSPropertyID unresolvedProperty)
+CSSValue* CSSPropertyParser::legacyParseValue(CSSPropertyID unresolvedProperty)
 {
     CSSPropertyID propId = resolveCSSPropertyID(unresolvedProperty);
 
     // Note: m_parsedCalculation is used to pass the calc value to validUnit and then cleared at the end of this function.
     // FIXME: This is to avoid having to pass parsedCalc to all validUnit callers.
     ASSERT(!m_parsedCalculation);
 
-    RawPtr<CSSValue> parsedValue = nullptr;
+    CSSValue* parsedValue = nullptr;
 
     switch (propId) {
     case CSSPropertyGridAutoFlow:
         ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
         parsedValue = parseGridAutoFlow(*m_valueList);
         break;
 
     // Everything else is handled in CSSPropertyParser.cpp
     default:
         return nullptr;
     }
 
     ASSERT(!m_parsedCalculation);
     if (parsedValue) {
         if (!m_valueList->current() || inShorthand())
-            return parsedValue.release();
+            return parsedValue;
     }
     return nullptr;
 }
 
 bool CSSPropertyParser::legacyParseShorthand(CSSPropertyID propertyID, bool important)
 {
     switch (propertyID) {
     case CSSPropertyGridTemplate:
         ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
         return parseGridTemplateShorthand(important);
@@ skipping 12 matching lines @@
 {
     return value.id == CSSValueInitial || value.id == CSSValueInherit || value.id == CSSValueUnset || value.id == CSSValueDefault;
 }
 
 static inline bool isValidCustomIdentForGridPositions(const CSSParserValue& value)
 {
     // FIXME: we need a more general solution for <custom-ident> in all properties.
     return value.m_unit == CSSParserValue::Identifier && value.id != CSSValueSpan && value.id != CSSValueAuto && !isCSSWideKeyword(value);
 }
 
-RawPtr<CSSValue> CSSPropertyParser::parseGridTemplateColumns(bool important)
+CSSValue* CSSPropertyParser::parseGridTemplateColumns(bool important)
 {
     if (!(m_valueList->current() && isForwardSlashOperator(m_valueList->current()) && m_valueList->next()))
         return nullptr;
-    if (RawPtr<CSSValue> columnsValue = parseGridTrackList()) {
+    if (CSSValue* columnsValue = parseGridTrackList()) {
         if (m_valueList->current())
             return nullptr;
         return columnsValue;
     }
 
     return nullptr;
 }
 
 bool CSSPropertyParser::parseGridTemplateRowsAndAreasAndColumns(bool important)
 {
     NamedGridAreaMap gridAreaMap;
     size_t rowCount = 0;
     size_t columnCount = 0;
     bool trailingIdentWasAdded = false;
-    RawPtr<CSSValueList> templateRows = CSSValueList::createSpaceSeparated();
+    CSSValueList* templateRows = CSSValueList::createSpaceSeparated();
 
     // At least template-areas strings must be defined.
     if (!m_valueList->current() || isForwardSlashOperator(m_valueList->current()))
         return false;
 
     while (m_valueList->current() && !isForwardSlashOperator(m_valueList->current())) {
         // Handle leading <custom-ident>*.
         if (!parseGridLineNames(*m_valueList, *templateRows, trailingIdentWasAdded ? toCSSGridLineNamesValue(templateRows->item(templateRows->length() - 1)) : nullptr))
             return false;
 
         // Handle a template-area's row.
         CSSParserValue* currentValue = m_valueList->current();
         if (!currentValue || currentValue->m_unit != CSSParserValue::String)
             return false;
         if (!parseGridTemplateAreasRow(currentValue->string, gridAreaMap, rowCount, columnCount))
             return false;
         m_valueList->next();
         ++rowCount;
 
         // Handle template-rows's track-size.
         if (m_valueList->current() && m_valueList->current()->m_unit != CSSParserValue::Operator && m_valueList->current()->m_unit != CSSParserValue::String) {
-            RawPtr<CSSValue> value = parseGridTrackSize(*m_valueList);
+            CSSValue* value = parseGridTrackSize(*m_valueList);
             if (!value)
                 return false;
             templateRows->append(value);
         } else {
             templateRows->append(cssValuePool().createIdentifierValue(CSSValueAuto));
         }
 
         // This will handle the trailing/leading <custom-ident>* in the grammar.
         if (!parseGridLineNames(*m_valueList, *templateRows))
             return false;
         trailingIdentWasAdded = templateRows->item(templateRows->length() - 1)->isGridLineNamesValue();
     }
 
-    RawPtr<CSSValue> columnsValue = nullptr;
+    CSSValue* columnsValue = nullptr;
     if (m_valueList->current()) {
         ASSERT(isForwardSlashOperator(m_valueList->current()));
         columnsValue = parseGridTemplateColumns(important);
         if (!columnsValue)
             return false;
         // The template-columns <track-list> can't be 'none'.
         if (columnsValue->isPrimitiveValue() && toCSSPrimitiveValue(*columnsValue).getValueID() == CSSValueNone)
             return false;
     }
 
-    addProperty(CSSPropertyGridTemplateRows, templateRows.release(), important);
-    addProperty(CSSPropertyGridTemplateColumns, columnsValue ? columnsValue.release() : cssValuePool().createIdentifierValue(CSSValueNone), important);
+    addProperty(CSSPropertyGridTemplateRows, templateRows, important);
+    addProperty(CSSPropertyGridTemplateColumns, columnsValue ? columnsValue : cssValuePool().createIdentifierValue(CSSValueNone), important);
 
-    RawPtr<CSSValue> templateAreas = CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
-    addProperty(CSSPropertyGridTemplateAreas, templateAreas.release(), important);
+    CSSValue* templateAreas = CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
+    addProperty(CSSPropertyGridTemplateAreas, templateAreas, important);
 
     return true;
 }
 
 
 bool CSSPropertyParser::parseGridTemplateShorthand(bool important)
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     ShorthandScope scope(this, CSSPropertyGridTemplate);
     ASSERT(gridTemplateShorthand().length() == 3);
 
     // At least "none" must be defined.
     if (!m_valueList->current())
         return false;
 
     bool firstValueIsNone = m_valueList->current()->id == CSSValueNone;
 
     // 1- 'none' case.
     if (firstValueIsNone && !m_valueList->next()) {
         addProperty(CSSPropertyGridTemplateColumns, cssValuePool().createIdentifierValue(CSSValueNone), important);
         addProperty(CSSPropertyGridTemplateRows, cssValuePool().createIdentifierValue(CSSValueNone), important);
         addProperty(CSSPropertyGridTemplateAreas, cssValuePool().createIdentifierValue(CSSValueNone), important);
         return true;
     }
 
     // 2- <grid-template-rows> / <grid-template-columns>
-    RawPtr<CSSValue> rowsValue = nullptr;
+    CSSValue* rowsValue = nullptr;
     if (firstValueIsNone) {
         rowsValue = cssValuePool().createIdentifierValue(CSSValueNone);
     } else {
         rowsValue = parseGridTrackList();
     }
 
     if (rowsValue) {
-        RawPtr<CSSValue> columnsValue = parseGridTemplateColumns(important);
+        CSSValue* columnsValue = parseGridTemplateColumns(important);
         if (!columnsValue)
             return false;
 
-        addProperty(CSSPropertyGridTemplateRows, rowsValue.release(), important);
-        addProperty(CSSPropertyGridTemplateColumns, columnsValue.release(), important);
+        addProperty(CSSPropertyGridTemplateRows, rowsValue, important);
+        addProperty(CSSPropertyGridTemplateColumns, columnsValue, important);
         addProperty(CSSPropertyGridTemplateAreas, cssValuePool().createIdentifierValue(CSSValueNone), important);
         return true;
     }
 
     // 3- [<line-names>? <string> <track-size>? <line-names>? ]+ syntax.
     // It requires to rewind parsing due to previous syntax failures.
     m_valueList->setCurrentIndex(0);
     return parseGridTemplateRowsAndAreasAndColumns(important);
 }
 
@@ skipping 14 matching lines @@
         return true;
     }
 
     // Need to rewind parsing to explore the alternative syntax of this shorthand.
     m_valueList->setCurrentIndex(0);
 
     // 2- <grid-auto-flow> [ <grid-auto-rows> [ / <grid-auto-columns> ]? ]
     if (!legacyParseAndApplyValue(CSSPropertyGridAutoFlow, important))
         return false;
 
-    RawPtr<CSSValue> autoColumnsValue = nullptr;
-    RawPtr<CSSValue> autoRowsValue = nullptr;
+    CSSValue* autoColumnsValue = nullptr;
+    CSSValue* autoRowsValue = nullptr;
 
     if (m_valueList->current()) {
         autoRowsValue = parseGridTrackSize(*m_valueList);
         if (!autoRowsValue)
             return false;
         if (m_valueList->current()) {
             if (!isForwardSlashOperator(m_valueList->current()) || !m_valueList->next())
                 return false;
             autoColumnsValue = parseGridTrackSize(*m_valueList);
             if (!autoColumnsValue)
@@ skipping 31 matching lines @@
 }
 
 bool CSSPropertyParser::parseGridLineNames(CSSParserValueList& inputList, CSSValueList& valueList, CSSGridLineNamesValue* previousNamedAreaTrailingLineNames)
 {
     if (!inputList.current() || inputList.current()->m_unit != CSSParserValue::Operator || inputList.current()->iValue != '[')
         return true;
 
     // Skip '['
     inputList.next();
 
-    RawPtr<CSSGridLineNamesValue> lineNames = previousNamedAreaTrailingLineNames;
+    CSSGridLineNamesValue* lineNames = previousNamedAreaTrailingLineNames;
     if (!lineNames)
         lineNames = CSSGridLineNamesValue::create();
 
     while (CSSParserValue* identValue = inputList.current()) {
         if (isClosingBracket(*identValue))
             break;
 
         if (!isValidCustomIdentForGridPositions(*identValue))
             return false;
 
-        RawPtr<CSSCustomIdentValue> lineName = createPrimitiveCustomIdentValue(identValue);
-        lineNames->append(lineName.release());
+        CSSCustomIdentValue* lineName = createPrimitiveCustomIdentValue(identValue);
+        lineNames->append(lineName);
         inputList.next();
     }
 
     if (!inputList.current() || !isClosingBracket(*inputList.current()))
         return false;
 
     if (!previousNamedAreaTrailingLineNames)
-        valueList.append(lineNames.release());
+        valueList.append(lineNames);
 
     // Consume ']'
     inputList.next();
     return true;
 }
 
 bool allTracksAreFixedSized(CSSValueList& valueList)
 {
     for (auto value : valueList) {
         if (value->isGridLineNamesValue())
             continue;
         // The auto-repeat value holds a <fixed-size> = <fixed-breadth> | minmax( <fixed-breadth>, <track-breadth> )
         if (value->isGridAutoRepeatValue()) {
             if (!allTracksAreFixedSized(toCSSValueList(*value)))
                 return false;
             continue;
         }
         ASSERT(value->isPrimitiveValue() || (value->isFunctionValue() && toCSSFunctionValue(*value).item(0)));
         const CSSPrimitiveValue& primitiveValue = value->isPrimitiveValue()
             ? toCSSPrimitiveValue(*value)
             : toCSSPrimitiveValue(*toCSSFunctionValue(*value).item(0));
         CSSValueID valueID = primitiveValue.getValueID();
         if (valueID == CSSValueMinContent || valueID == CSSValueMaxContent || valueID == CSSValueAuto || primitiveValue.isFlex())
             return false;
     }
     return true;
 }
 
-RawPtr<CSSValue> CSSPropertyParser::parseGridTrackList()
+CSSValue* CSSPropertyParser::parseGridTrackList()
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueNone) {
         m_valueList->next();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     }
 
-    RawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
+    CSSValueList* values = CSSValueList::createSpaceSeparated();
     // Handle leading  <custom-ident>*.
     if (!parseGridLineNames(*m_valueList, *values))
         return nullptr;
 
     bool seenTrackSizeOrRepeatFunction = false;
     bool seenAutoRepeat = false;
     while (CSSParserValue* currentValue = m_valueList->current()) {
         if (isForwardSlashOperator(currentValue))
             break;
         if (currentValue->m_unit == CSSParserValue::Function && currentValue->function->id == CSSValueRepeat) {
             bool isAutoRepeat;
             if (!parseGridTrackRepeatFunction(*values, isAutoRepeat))
                 return nullptr;
             if (isAutoRepeat && seenAutoRepeat)
                 return nullptr;
             seenTrackSizeOrRepeatFunction = true;
             seenAutoRepeat = seenAutoRepeat || isAutoRepeat;
         } else {
-            RawPtr<CSSValue> value = parseGridTrackSize(*m_valueList, seenAutoRepeat ? FixedSizeOnly : AllowAll);
+            CSSValue* value = parseGridTrackSize(*m_valueList, seenAutoRepeat ? FixedSizeOnly : AllowAll);
             if (!value)
                 return nullptr;
             values->append(value);
             seenTrackSizeOrRepeatFunction = true;
         }
         // This will handle the trailing <custom-ident>* in the grammar.
         if (!parseGridLineNames(*m_valueList, *values))
             return nullptr;
     }
 
@@ skipping 17 matching lines @@
 
     CSSParserValue* currentValue = arguments->valueAt(0);
     isAutoRepeat = currentValue->id == CSSValueAutoFill || currentValue->id == CSSValueAutoFit;
     if (!isAutoRepeat && !validUnit(currentValue, FPositiveInteger))
         return false;
 
     // The number of repetitions for <auto-repeat> is not important at parsing level
     // because it will be computed later, let's set it to 1.
     size_t repetitions = isAutoRepeat ? 1 : clampTo<size_t>(currentValue->fValue, 0, kGridMaxTracks);
 
-    RawPtr<CSSValueList> repeatedValues = isAutoRepeat ? CSSGridAutoRepeatValue::create(currentValue->id) : CSSValueList::createSpaceSeparated();
+    CSSValueList* repeatedValues = isAutoRepeat ? CSSGridAutoRepeatValue::create(currentValue->id) : CSSValueList::createSpaceSeparated();
     arguments->next(); // Skip the repetition count.
     arguments->next(); // Skip the comma.
 
     // Handle leading <custom-ident>*.
     if (!parseGridLineNames(*arguments, *repeatedValues))
         return false;
 
     size_t numberOfTracks = 0;
     TrackSizeRestriction restriction = isAutoRepeat ? FixedSizeOnly : AllowAll;
     while (arguments->current()) {
         if (isAutoRepeat && numberOfTracks)
             return false;
 
-        RawPtr<CSSValue> trackSize = parseGridTrackSize(*arguments, restriction);
+        CSSValue* trackSize = parseGridTrackSize(*arguments, restriction);
         if (!trackSize)
             return false;
 
         repeatedValues->append(trackSize);
         ++numberOfTracks;
 
         // This takes care of any trailing <custom-ident>* in the grammar.
         if (!parseGridLineNames(*arguments, *repeatedValues))
             return false;
     }
 
     // We should have found at least one <track-size> or else it is not a valid <track-list>.
     if (!numberOfTracks)
         return false;
 
     if (isAutoRepeat) {
-        list.append(repeatedValues.release());
+        list.append(repeatedValues);
     } else {
         // We clamp the number of repetitions to a multiple of the repeat() track list's size, while staying below the max
         // grid size.
         repetitions = std::min(repetitions, kGridMaxTracks / numberOfTracks);
 
         for (size_t i = 0; i < repetitions; ++i) {
             for (size_t j = 0; j < repeatedValues->length(); ++j)
                 list.append(repeatedValues->item(j));
         }
     }
 
     // parseGridTrackSize iterated over the repeat arguments, move to the next value.
     m_valueList->next();
     return true;
 }
 
 
-RawPtr<CSSValue> CSSPropertyParser::parseGridTrackSize(CSSParserValueList& inputList, TrackSizeRestriction restriction)
+CSSValue* CSSPropertyParser::parseGridTrackSize(CSSParserValueList& inputList, TrackSizeRestriction restriction)
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     CSSParserValue* currentValue = inputList.current();
     inputList.next();
 
     if (currentValue->id == CSSValueAuto)
         return restriction == AllowAll ? cssValuePool().createIdentifierValue(CSSValueAuto) : nullptr;
 
     if (currentValue->m_unit == CSSParserValue::Function && currentValue->function->id == CSSValueMinmax) {
         // The spec defines the following grammar: minmax( <track-breadth> , <track-breadth> )
         CSSParserValueList* arguments = currentValue->function->args.get();
         if (!arguments || arguments->size() != 3 || !isComma(arguments->valueAt(1)))
             return nullptr;
 
-        RawPtr<CSSPrimitiveValue> minTrackBreadth = parseGridBreadth(arguments->valueAt(0), restriction);
+        CSSPrimitiveValue* minTrackBreadth = parseGridBreadth(arguments->valueAt(0), restriction);
         if (!minTrackBreadth)
             return nullptr;
 
-        RawPtr<CSSPrimitiveValue> maxTrackBreadth = parseGridBreadth(arguments->valueAt(2));
+        CSSPrimitiveValue* maxTrackBreadth = parseGridBreadth(arguments->valueAt(2));
         if (!maxTrackBreadth)
             return nullptr;
 
-        RawPtr<CSSFunctionValue> result = CSSFunctionValue::create(CSSValueMinmax);
+        CSSFunctionValue* result = CSSFunctionValue::create(CSSValueMinmax);
         result->append(minTrackBreadth);
         result->append(maxTrackBreadth);
-        return result.release();
+        return result;
     }
 
     return parseGridBreadth(currentValue, restriction);
 }
 
-RawPtr<CSSPrimitiveValue> CSSPropertyParser::parseGridBreadth(CSSParserValue* currentValue, TrackSizeRestriction restriction)
+CSSPrimitiveValue* CSSPropertyParser::parseGridBreadth(CSSParserValue* currentValue, TrackSizeRestriction restriction)
 {
     if (currentValue->id == CSSValueMinContent || currentValue->id == CSSValueMaxContent || currentValue->id == CSSValueAuto)
         return restriction == AllowAll ? cssValuePool().createIdentifierValue(currentValue->id) : nullptr;
 
     if (currentValue->unit() == CSSPrimitiveValue::UnitType::Fraction) {
         if (restriction == FixedSizeOnly)
             return nullptr;
 
         double flexValue = currentValue->fValue;
 
@@ skipping 97 matching lines @@
                 return false;
 
             gridArea.rows = GridSpan::translatedDefiniteGridSpan(gridArea.rows.startLine(), gridArea.rows.endLine() + 1);
         }
         currentCol = lookAheadCol - 1;
     }
 
     return true;
 }
 
-RawPtr<CSSValue> CSSPropertyParser::parseGridAutoFlow(CSSParserValueList& list)
+CSSValue* CSSPropertyParser::parseGridAutoFlow(CSSParserValueList& list)
 {
     // [ row | column ] || dense
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     CSSParserValue* value = list.current();
     if (!value)
         return nullptr;
 
-    RawPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
+    CSSValueList* parsedValues = CSSValueList::createSpaceSeparated();
 
     // First parameter.
     CSSValueID firstId = value->id;
     if (firstId != CSSValueRow && firstId != CSSValueColumn && firstId != CSSValueDense)
         return nullptr;
     parsedValues->append(cssValuePool().createIdentifierValue(firstId));
 
     // Second parameter, if any.
     value = list.next();
     if (value) {
@@ skipping 26 matching lines @@
     ASSERT(!m_parsedCalculation);
     m_parsedCalculation = CSSCalcValue::create(args, range);
 
     if (!m_parsedCalculation)
         return false;
 
     return true;
 }
 
 } // namespace blink